{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HW5-Lab1 - 微调BERT预训练模型 - Math Word Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 数据集准备\n",
    "\n",
    "我们仍然使用 [Math23K](https://paperswithcode.com/dataset/math23k) 数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import Tensor\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Set seed.\n",
    "seed = 42\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed(seed)\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小: 22162\n",
      "测试集大小: 1000\n",
      "问题 1: 甲数除以乙数的商是temp_a，如果甲数增加temp_b，则甲数是乙的temp_c倍．原来甲数=．\n",
      "方程 1: ['temp_b', '/', '(', 'temp_c', '-', 'temp_a', ')', '*', 'temp_a']\n",
      "--------------------\n",
      "问题 2: 客车和货车分别从A、B两站同时相向开出，temp_a小时后相遇．相遇后，两车仍按原速度前进，当它们相距temp_b千米时，货车行了全程的temp_c%，客车已行的路程与未行的路程比是temp_d：temp_e．求A、B两站间的路程．\n",
      "方程 2: ['temp_b', '/', '(', 'temp_c', '+', '(', '(', 'temp_d', ')', '/', '(', 'temp_d', '+', 'temp_e', ')', ')', '-', '1', ')']\n",
      "--------------------\n",
      "问题 3: 图书角有书temp_a本，第一天借出了temp_b，第二天又还回temp_c本，现在图书角有多少本书？\n",
      "方程 3: ['temp_a', '*', '(', '1', '-', 'temp_b', ')', '+', 'temp_c']\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "def read_math23k_data(path):\n",
    "    \"\"\"读取 Math23K 数据集。\"\"\"\n",
    "    with open(path, \"r\", encoding=\"utf-8\") as f:\n",
    "        data = json.load(f)\n",
    "    problems = [item[\"text\"].replace(\" \", \"\") for item in data]\n",
    "    equations = [item[\"target_template\"][2:] for item in data]  # 移除方程的 'x=' 前缀\n",
    "    return problems, equations\n",
    "\n",
    "\n",
    "# 加载训练集和测试集\n",
    "train_path, test_path = \"data/train.json\", \"data/test.json\"\n",
    "train_problems, train_equations = read_math23k_data(train_path)\n",
    "test_problems, test_equations = read_math23k_data(test_path)\n",
    "\n",
    "print(f\"训练集大小: {len(train_problems)}\")\n",
    "print(f\"测试集大小: {len(test_problems)}\")\n",
    "\n",
    "# 打印一些示例数据\n",
    "for i in range(3):\n",
    "    print(f\"问题 {i+1}: {train_problems[i]}\")\n",
    "    print(f\"方程 {i+1}: {train_equations[i]}\")\n",
    "    print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 数据预处理\n",
    "\n",
    "在将数据输入 BERT 模型之前，我们需要对数据进行预处理，这包括：\n",
    "- 不同于之前，我们这里使用 BERT 的 tokenizer 对 problems 进行编码\n",
    "- 对于 equations 的编码和之前一样\n",
    "\n",
    "### 2.1 使用 BERT Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 101, 4508, 3144, 7370,  809,  734, 3144, 4638, 1555, 3221, 8282, 9085,\n",
      "         142,  143, 8024, 1963, 3362, 4508, 3144, 1872, 1217, 8282, 9085,  142,\n",
      "         144, 8024, 1156, 4508, 3144, 3221,  734, 4638, 8282, 9085,  142,  145,\n",
      "         945, 8026, 1333, 3341, 4508, 3144,  134, 8026,  102,    0,    0,    0,\n",
      "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0])\n",
      "[CLS] 甲 数 除 以 乙 数 的 商 是 temp _ a ， 如 果 甲 数 增 加 temp _ b ， 则 甲 数 是 乙 的 temp _ c 倍 ． 原 来 甲 数 = ． [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]\n"
     ]
    }
   ],
   "source": [
    "from transformers import BertTokenizer\n",
    "\n",
    "# 使用 bert-base-chinese 预训练模型\n",
    "src_tokenizer = BertTokenizer.from_pretrained(\"bert-base-chinese\")\n",
    "\n",
    "\n",
    "def preprocess_src_sentence(sentence, tokenizer, max_len):\n",
    "    inputs = tokenizer(\n",
    "        sentence,\n",
    "        add_special_tokens=True,\n",
    "        return_tensors=\"pt\",\n",
    "        padding=\"max_length\",\n",
    "        truncation=True,\n",
    "        max_length=max_len,\n",
    "    )\n",
    "    return inputs[\"input_ids\"].squeeze()\n",
    "\n",
    "\n",
    "out = preprocess_src_sentence(train_problems[0], src_tokenizer, 60)\n",
    "print(out)\n",
    "print(src_tokenizer.decode(out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这段代码展示了如何使用预训练的 bert-base-chinese 模型的 tokenizer 对问题进行编码。preprocess_src_sentence 函数接收一个句子、tokenizer 和最大长度作为输入，并将句子转换为 BERT 模型可以理解的数字表示。\n",
    "\n",
    "### 2.2 对 equations 进行编码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Target Vocab Size: 30\n",
      "tensor([ 2,  5,  6,  7, 10, 11,  4,  8,  9,  4,  3,  1,  1,  1,  1,  1,  1,  1,\n",
      "         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,\n",
      "         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1])\n",
      "<bos> temp_b / ( temp_c - temp_a ) * temp_a <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "\n",
    "class Vocab:\n",
    "    def __init__(self, sentence_list, min_count=1):\n",
    "        self.token2idx = {\"<unk>\": 0, \"<pad>\": 1, \"<bos>\": 2, \"<eos>\": 3}\n",
    "        self.build_vocab(sentence_list, min_count)\n",
    "\n",
    "    def build_vocab(self, sentence_list, min_count):\n",
    "        token_counts = Counter([token for sentence in sentence_list for token in sentence])\n",
    "        sorted_tokens = [token for token, count in token_counts.items() if count >= min_count]\n",
    "        sorted_tokens.sort(key=lambda token: token_counts[token], reverse=True)\n",
    "        for token in sorted_tokens:\n",
    "            self.token2idx[token] = len(self.token2idx)\n",
    "        self.idx2token = {idx: token for token, idx in self.token2idx.items()}\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.idx2token)\n",
    "\n",
    "    def token_to_index(self, token):\n",
    "        return self.token2idx.get(token, self.token2idx[\"<unk>\"])\n",
    "\n",
    "    def index_to_token(self, index):\n",
    "        return self.idx2token.get(index, \"<unk>\")\n",
    "\n",
    "    def to_tokens(self, indices):\n",
    "        return [self.index_to_token(index) for index in indices]\n",
    "\n",
    "    def to_indices(self, tokens):\n",
    "        return [self.token_to_index(token) for token in tokens]\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Vocab(size={len(self)})\"\n",
    "\n",
    "    def __getitem__(self, tokens):\n",
    "        if not isinstance(tokens, (list, tuple)):\n",
    "            return self.token_to_index(tokens)\n",
    "        return [self.token_to_index(token) for token in tokens]\n",
    "\n",
    "\n",
    "def preprocess_tgt_sentence(sentence, vocab, max_len):\n",
    "    sentence = [\"<bos>\"] + sentence + [\"<eos>\"]\n",
    "    indices = vocab[sentence]\n",
    "    indices = torch.tensor(indices)\n",
    "    if len(indices) > max_len:\n",
    "        indices = indices[:max_len]\n",
    "    else:\n",
    "        pad_size = max_len - len(indices)\n",
    "        indices = F.pad(indices, (0, pad_size), value=vocab[\"<pad>\"])\n",
    "    return indices\n",
    "\n",
    "\n",
    "tgt_vocab = Vocab(train_equations + test_equations)\n",
    "print(f\"Target Vocab Size: {len(tgt_vocab)}\")\n",
    "\n",
    "out = preprocess_tgt_sentence(train_equations[0], tgt_vocab, 50)\n",
    "print(out)\n",
    "print(\" \".join(tgt_vocab.to_tokens(out.tolist())))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 创建数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Math23kDataset(Dataset):\n",
    "    def __init__(self, problems, equations, src_tokenizer, tgt_vocab, src_max_len=120, tgt_max_len=50):\n",
    "        self.src_data = [preprocess_src_sentence(sentence, src_tokenizer, src_max_len) for sentence in problems]\n",
    "        self.tgt_data = [preprocess_tgt_sentence(sentence, tgt_vocab, tgt_max_len) for sentence in equations]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.src_data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.src_data[idx], self.tgt_data[idx]\n",
    "\n",
    "\n",
    "# 创建数据集\n",
    "train_dataset = Math23kDataset(train_problems, train_equations, src_tokenizer, tgt_vocab)\n",
    "test_dataset = Math23kDataset(test_problems, test_equations, src_tokenizer, tgt_vocab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 构建模型\n",
    "\n",
    "这里我们定义一个 BertSeq2SeqTransformer 模型，它使用预训练的 BERT 模型作为编码器，并使用 Transformer 解码器生成公式，其中 BERT 模型的权重固定，不参与训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import math\n",
    "\n",
    "\n",
    "class PositionalEncoding(nn.Module):\n",
    "    def __init__(self, emb_size: int, dropout: float, maxlen: int = 5000):\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "        den = torch.exp(-torch.arange(0, emb_size, 2) * math.log(10000) / emb_size)\n",
    "        pos = torch.arange(0, maxlen).reshape(maxlen, 1)\n",
    "        pos_embedding = torch.zeros((maxlen, emb_size))\n",
    "        pos_embedding[:, 0::2] = torch.sin(pos * den)\n",
    "        pos_embedding[:, 1::2] = torch.cos(pos * den)\n",
    "\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.register_buffer(\"pos_embedding\", pos_embedding)\n",
    "\n",
    "    def forward(self, token_embedding: torch.Tensor):\n",
    "        return self.dropout(token_embedding + self.pos_embedding[: token_embedding.size(1), :])\n",
    "\n",
    "\n",
    "class TokenEmbedding(nn.Module):\n",
    "    def __init__(self, vocab_size: int, emb_size):\n",
    "        super(TokenEmbedding, self).__init__()\n",
    "        self.embedding = nn.Embedding(vocab_size, emb_size)\n",
    "        self.emb_size = emb_size\n",
    "\n",
    "    def forward(self, tokens: torch.Tensor):\n",
    "        return self.embedding(tokens.long()) * math.sqrt(self.emb_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import BertModel\n",
    "\n",
    "\n",
    "class BertSeq2SeqTransformer(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        num_decoder_layers: int,\n",
    "        emb_size,\n",
    "        nhead,\n",
    "        tgt_vocab_size,\n",
    "        dim_feedforward: int = 512,\n",
    "        dropout: float = 0.1,\n",
    "    ):\n",
    "        super(BertSeq2SeqTransformer, self).__init__()\n",
    "\n",
    "        # 使用预训练的 BERT 模型作为编码器\n",
    "        self.bert = BertModel.from_pretrained(\"bert-base-chinese\")\n",
    "        # 冻结BERT模型的参数，使其在训练过程中不被更新\n",
    "        for param in self.bert.parameters():\n",
    "            param.requires_grad = False\n",
    "        self.bert_output_linear = nn.Linear(768, emb_size)\n",
    "\n",
    "        # 解码器部分\n",
    "        self.positional_encoding = PositionalEncoding(emb_size, dropout=dropout)\n",
    "        self.tgt_tok_emb = TokenEmbedding(tgt_vocab_size, emb_size)\n",
    "        decoder_layer = nn.TransformerDecoderLayer(\n",
    "            d_model=emb_size, nhead=nhead, dim_feedforward=dim_feedforward, dropout=dropout, batch_first=True\n",
    "        )\n",
    "        self.transformer_decoder = nn.TransformerDecoder(decoder_layer, num_layers=num_decoder_layers)\n",
    "        self.generator = nn.Linear(emb_size, tgt_vocab_size)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        src: torch.Tensor,\n",
    "        trg: torch.Tensor,\n",
    "        src_mask: torch.Tensor,\n",
    "        tgt_mask: torch.Tensor,\n",
    "        src_padding_mask: torch.Tensor,\n",
    "        tgt_padding_mask: torch.Tensor,\n",
    "    ):\n",
    "        # TODO: 实现模型的前向传播\n",
    "        \n",
    "\n",
    "    def encode(self, src: torch.Tensor, src_mask: torch.Tensor, src_key_padding_mask=None):\n",
    "        with torch.no_grad():\n",
    "            src_emb = self.bert(src, attention_mask=~src_key_padding_mask)[0]\n",
    "        src_emb = self.bert_output_linear(src_emb)\n",
    "        return src_emb\n",
    "\n",
    "    def decode(self, tgt: torch.Tensor, memory: torch.Tensor, tgt_mask: torch.Tensor):\n",
    "        return self.transformer_decoder(self.positional_encoding(self.tgt_tok_emb(tgt)), memory, tgt_mask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 训练模型\n",
    "\n",
    "### 4.1 定义训练函数和评估函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "SRC_PAD_IDX, TGT_PAD_IDX = 0, 1\n",
    "\n",
    "\n",
    "def create_mask(src, tgt):\n",
    "    src_seq_len = src.shape[1]\n",
    "    tgt_seq_len = tgt.shape[1]\n",
    "\n",
    "    src_mask = torch.zeros((src_seq_len, src_seq_len), dtype=torch.bool, device=DEVICE)\n",
    "    tgt_mask = torch.ones((tgt_seq_len, tgt_seq_len), dtype=torch.bool, device=DEVICE).triu_(diagonal=1)\n",
    "\n",
    "    src_padding_mask = src == SRC_PAD_IDX\n",
    "    tgt_padding_mask = tgt == TGT_PAD_IDX\n",
    "    return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epoch(model, train_loader, optimizer, loss_fn):\n",
    "    model.train()\n",
    "    losses = 0\n",
    "    for src, tgt in train_loader:\n",
    "        src, tgt = src.to(DEVICE), tgt.to(DEVICE)\n",
    "        tgt_input = tgt[:, :-1]\n",
    "        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)\n",
    "\n",
    "        logits = model(src, tgt_input, src_mask, tgt_mask, src_padding_mask, tgt_padding_mask)\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        tgt_out = tgt[:, 1:]\n",
    "        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))\n",
    "        loss.backward()\n",
    "\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1)\n",
    "\n",
    "        optimizer.step()\n",
    "        losses += loss.item()\n",
    "\n",
    "    return losses / len(train_loader)\n",
    "\n",
    "\n",
    "def evaluate(model, val_loader, loss_fn):\n",
    "    model.eval()\n",
    "    losses = 0\n",
    "    for src, tgt in val_loader:\n",
    "        src, tgt = src.to(DEVICE), tgt.to(DEVICE)\n",
    "        tgt_input = tgt[:, :-1]\n",
    "        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)\n",
    "\n",
    "        logits = model(src, tgt_input, src_mask, tgt_mask, src_padding_mask, tgt_padding_mask)\n",
    "\n",
    "        tgt_out = tgt[:, 1:]\n",
    "        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))\n",
    "        losses += loss.item()\n",
    "\n",
    "    return losses / len(val_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 设置超参数和初始化模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total trainable params: 1.164446 M\n"
     ]
    }
   ],
   "source": [
    "TGT_VOCAB_SIZE = len(tgt_vocab)\n",
    "EMB_SIZE = 128\n",
    "NHEAD = 8  # 注意力头数\n",
    "FFN_HID_DIM = 512  # FeedForward隐藏层维度\n",
    "NUM_LAYERS = 4  # Transformer层数\n",
    "\n",
    "BATCH_SIZE = 64\n",
    "LEARNING_RATE = 0.0008\n",
    "DROP_OUT = 0.1\n",
    "\n",
    "model = BertSeq2SeqTransformer(NUM_LAYERS, EMB_SIZE, NHEAD, TGT_VOCAB_SIZE, FFN_HID_DIM, DROP_OUT)\n",
    "\n",
    "total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "print(\"Total trainable params:\", total_params / 1e6, \"M\")\n",
    "\n",
    "model = model.to(DEVICE)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss(ignore_index=tgt_vocab[\"<pad>\"])\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss: 0.975, Val loss: 0.722, Epoch time = 62.421s\n",
      "Epoch: 1, Train loss: 0.676, Val loss: 0.605, Epoch time = 62.519s\n",
      "Epoch: 2, Train loss: 0.583, Val loss: 0.519, Epoch time = 62.566s\n",
      "Epoch: 3, Train loss: 0.529, Val loss: 0.488, Epoch time = 62.587s\n",
      "Epoch: 4, Train loss: 0.486, Val loss: 0.475, Epoch time = 62.608s\n",
      "Epoch: 5, Train loss: 0.460, Val loss: 0.443, Epoch time = 62.606s\n",
      "Epoch: 6, Train loss: 0.437, Val loss: 0.432, Epoch time = 62.606s\n",
      "Epoch: 7, Train loss: 0.421, Val loss: 0.421, Epoch time = 62.618s\n",
      "Epoch: 8, Train loss: 0.402, Val loss: 0.396, Epoch time = 62.623s\n",
      "Epoch: 9, Train loss: 0.387, Val loss: 0.388, Epoch time = 62.611s\n",
      "Epoch: 10, Train loss: 0.376, Val loss: 0.393, Epoch time = 62.619s\n",
      "Epoch: 11, Train loss: 0.363, Val loss: 0.385, Epoch time = 62.625s\n",
      "Epoch: 12, Train loss: 0.354, Val loss: 0.379, Epoch time = 62.633s\n",
      "Epoch: 13, Train loss: 0.346, Val loss: 0.371, Epoch time = 62.644s\n",
      "Epoch: 14, Train loss: 0.340, Val loss: 0.362, Epoch time = 62.626s\n",
      "Epoch: 15, Train loss: 0.333, Val loss: 0.364, Epoch time = 62.627s\n",
      "Epoch: 16, Train loss: 0.324, Val loss: 0.357, Epoch time = 62.620s\n",
      "Epoch: 17, Train loss: 0.317, Val loss: 0.361, Epoch time = 62.632s\n",
      "Epoch: 18, Train loss: 0.312, Val loss: 0.363, Epoch time = 62.637s\n",
      "Epoch: 19, Train loss: 0.304, Val loss: 0.351, Epoch time = 62.638s\n",
      "Epoch: 20, Train loss: 0.299, Val loss: 0.363, Epoch time = 62.635s\n",
      "Epoch: 21, Train loss: 0.297, Val loss: 0.369, Epoch time = 62.631s\n",
      "Epoch: 22, Train loss: 0.291, Val loss: 0.356, Epoch time = 62.628s\n",
      "Epoch: 23, Train loss: 0.286, Val loss: 0.357, Epoch time = 62.615s\n",
      "Epoch: 24, Train loss: 0.283, Val loss: 0.347, Epoch time = 62.636s\n",
      "Epoch: 25, Train loss: 0.276, Val loss: 0.351, Epoch time = 62.640s\n",
      "Epoch: 26, Train loss: 0.275, Val loss: 0.340, Epoch time = 62.645s\n",
      "Epoch: 27, Train loss: 0.273, Val loss: 0.343, Epoch time = 62.657s\n",
      "Epoch: 28, Train loss: 0.268, Val loss: 0.337, Epoch time = 62.648s\n",
      "Epoch: 29, Train loss: 0.265, Val loss: 0.333, Epoch time = 62.632s\n"
     ]
    }
   ],
   "source": [
    "from timeit import default_timer as timer\n",
    "\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "NUM_EPOCHS = 30\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "val_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE)\n",
    "\n",
    "train_loss_list, valid_loss_list = [], []\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    start_time = timer()\n",
    "    train_loss = train_epoch(model, train_loader, optimizer, criterion)\n",
    "    val_loss = evaluate(model, val_loader, criterion)\n",
    "    end_time = timer()\n",
    "    train_loss_list.append(train_loss)\n",
    "    valid_loss_list.append(val_loss)\n",
    "    print(\n",
    "        (\n",
    "            f\"Epoch: {epoch}, Train loss: {train_loss:.3f}, Val loss: {val_loss:.3f}, \"\n",
    "            f\"Epoch time = {(end_time - start_time):.3f}s\"\n",
    "        )\n",
    "    )\n",
    "\n",
    "# 保存模型\n",
    "torch.save(model.state_dict(), \"bert_model.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABpwAAAS0CAYAAAB9vatGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdebiVZb0//veCvQGB7UZwZJAoHNOSnNKcp0zBrE5pzmiZlWXn2K86diqrb8fj8WjHMu2YirNmVirgQCqYOITzXE65GUQJQZlBYP3+IDasxQbd7L3X2rBfr+viup7nfu5n3Z+FZ50/eHd/7kKxWCwGAAAAAAAA1lKnahcAAAAAAADAuk3gBAAAAAAAQIsInAAAAAAAAGgRgRMAAAAAAAAtInACAAAAAACgRQROAAAAAAAAtIjACQAAAAAAgBYROAEAAAAAANAiAicAAAAAAABaROAEAAAAAABAiwicAAAAAAAAaBGBEwAAAAAAAC0icAIAAAAAAKBFBE4AAAAAAAC0iMAJAAAAAACAFhE4AQAAAAAA0CI11S6AtrdgwYI888wzSZJNNtkkNTX+swMAAAAAQEe1ePHi/OMf/0iS7LjjjunWrVuLP1Py0AE888wz2W233apdBgAAAAAA0M5MmDAhu+66a4s/R0s9AAAAAAAAWsQOpw5gk002abyeMGFCtthiiypWAwAAAAAAVNPUqVMbO6OtnCG0hMCpA1j5zKYtttgi/fv3r2I1AAAAAABAe7FyhtASWuoBAAAAAADQIgInAAAAAAAAWqTDBk7Tpk3LqFGj8sMf/jCf+tSnsvHGG6dQKKRQKOSkk05qkzVvuOGGHHLIIdl8883TrVu3DBw4MMcdd1weeuihNlkPAAAAAACgEjrsGU6bbbZZxdaaP39+/uVf/iW33357yfjEiRNz3XXX5YYbbsgPf/jD/OhHP6pYTQAAAAAAAK2lw+5wWtmWW26ZQw45pM0+/+STT24Mm/bff//ccsstmTBhQi6//PJ86EMfytKlS3P22Wfn0ksvbbMaAAAAAAAA2kqH3eH0wx/+MLvuumt23XXXbLbZZnnttdcyaNCgVl/n3nvvzY033pgkGTZsWP74xz+mc+fOSZJdd901RxxxRHbeeedMnDgx3/3ud/P5z38+G220UavXAQAAAAAA0FY67A6nH//4xxk6dGibt9b7n//5nyRJTU1NLr744sawabmNN9445557bpLk7bffzmWXXdam9QAAAAAAALS2Dhs4VcLs2bNzzz33JEkOOuig9O/fv8l5n/3sZ7PhhhsmSf74xz9WrD4AAAAAAIDWIHBqQ4888kgWLVqUJNl3331XO69Lly75+Mc/3vjOu+++W5H6AAAAAAAAWkOHPcOpEp5//vnG62233XaNc7fddtuMGTMmixcvzksvvZTtt9/+fa8zefLkNT6fOnXq+/4sAAAAAACA5hI4taGVg6DVtdNbbsCAAY3XkyZNalbgtPK7AAAAAACVsnTp0syZMyezZs3KokWLsmTJkmqXBOu9zp07p0uXLtlwww3Ts2fPdOrUPprZCZza0OzZsxuve/bsuca5PXr0aLyeM2dOm9UEAAAAANAaZs+enSlTpqRYLFa7FOhQFi9enIULF2b27NkpFArp169f6urqql2WwKktLViwoPG6S5cua5zbtWvXxuv58+c3a51Jkyat8fnUqVOz2267NeszAQAAAABWp6mwqVAopHPnzlWsCjqGJUuWNP72isVipkyZ0i5CJ4FTG+rWrVvj9aJFi9Y4d+HChY3XG2ywQbPWea92fQAAAAAArWXp0qUlYVPPnj3Tu3fvdO/ePYVCocrVwfqvWCxm3rx5mTFjRubMmdMYOm299dZVba/XPhr7radWThPfq03e3LlzG6/fq/0eAAAAAEC1LP8H7mTZv2X2798/PXr0EDZBhRQKhfTo0SP9+/dvzBOKxWLVj+sROLWhlXceTZ48eY1zV26LN2DAgDarCQAAAACgJWbNmtV43bt3b0ETVEmhUEjv3r0b71f+bVaDwKkNbb/99o3Xf/3rX9c4d/nzmpqabLXVVm1aFwAAAADA2lp+fEihUEj37t2rXA10bCu3snyvo33amsCpDe26667p0qVLkuS+++5b7bxFixbl4Ycfbnyntra2IvUBAAAAADTXkiVLkiSdO3e2uwmqrFAopHPnzklW/DarReDUhurq6nLggQcmSe6+++7VttX7wx/+0LjV7TOf+UzF6gMAAAAAAGgNAqcWuPLKK1MoFFIoFHL22Wc3Oefb3/52kmTx4sX5+te/vkrCOH369Hz3u99NkvTq1Stf+tKX2rRmAAAAAACA1lZT7QKqZfz48Xn55Zcb76dPn954/fLLL+fKK68smX/SSSet1ToHHHBAjj766Nx444257bbbcvDBB+db3/pW+vbtm2eeeSY/+9nPMnHixCTJueeem4022mit1gEAAAAAAKiWDhs4XXbZZbnqqquafPbAAw/kgQceKBlb28ApSa644orMmjUrt99+e8aOHZuxY8eWPO/UqVN+8IMf5NRTT13rNQAAAAAAAKpFS70K2GCDDTJ69Ohcd911Ofjgg7PpppumS5cuGTBgQI455piMHz9+tS35AAAAAAAA2rtCsVgsVrsI2tbkyZMzYMCAJMmkSZPSv3//KlcEAAAAAKyrXnrppSxevDg1NTXZaqutql0OVVYoFJIkP/rRj6q6sWK//fbLfffdl3333Tfjxo2rWh3VsDa/ybbIDexwAgAAAAAAoEUETgAAAAAA0E5deeWVKRQKKRQKee2116pdDqxWTbULAAAAAAAA1k1O7WE5O5wAAAAAAABoEYETAAAAAAAALSJwAgAAAACAdmbcuHEpFAoZPnx449igQYMaz3Na/mfcuHGNz0866aQUCoV84AMfSJJMnTo13/3ud/PhD384dXV1q8yfOXNmRowYkeOOOy7bb799evbsmS5dumTzzTfPJz/5yVx66aVZtGjRGutcXsfZZ5+9yrPy86eWLl2aSy+9NHvuuWc22mij9OjRIx/5yEfys5/9LPPmzWvJX9f7Nn78+Bx//PH5wAc+kG7duqVXr14ZMmRI/uM//iP/+Mc/1vjuggUL8otf/CL77bdfNtlkk9TW1qZ3797ZZptt8qlPfSoXXHDBas/Zeuyxx3LKKadk6623To8ePdKtW7cMGDAgO++8c77+9a/ntttuW+fbEzrDCQAAAAAA1jMPP/xwhg0blunTp692zpAhQ9LQ0LDK+JtvvpkxY8ZkzJgx+fWvf53bb789m2++eYvqmTdvXg455JDcc889JePPPPNMnnnmmdx22225995706NHjxatszpLly7NN7/5zfzqV78qGV+4cGGefPLJPPnkk7nooovyu9/9LgcffPAq70+dOjUHHXRQnn/++ZLxmTNnZubMmXnxxRdz55135vXXX8///M//lMz5+c9/nm9/+9tZunRpyfjkyZMzefLkPP7447n44osze/bs9OzZs5W+ceUJnAAAAAAAoJ3Zdddd88wzz+TWW2/Nf/zHfyRJ7rrrrvTt27dk3qBBg1Z5d86cOfnc5z6XBQsW5Pvf/34OPvjgdO/ePc8880y22GKLxnlLlizJ7rvvnqFDh2bIkCHZbLPNsmjRovz973/PtddemzvvvDNPPPFEjj766JKdUWvjy1/+ch5++OGceOKJ+cIXvpDNN988EydOzH//93/noYceyoQJE/L//t//yznnnNOidVbne9/7XmPYNGjQoHz3u9/Nxz72scydOze33XZbLrroorzzzjsZOnRoJkyYkI9+9KMl73/jG99oDJuOO+64fPazn03fvn3TuXPnTJ06NY8++mhuvfXWVdZ9+umnG8OmQYMG5fTTT89OO+2U3r17Z/bs2fnb3/6WsWPHNvnuukbgBAAAAABAq1q6NHnrrWpXUVl9+iSdWvEQmx49emSHHXbIo48+2ji29dZbN7bLW5O33norPXv2zPjx40uCk1133bVk3r333putttpqlff33HPPHHvssRkxYkROPvnk3Hfffbnnnnty4IEHrvX3efDBB3PNNdfkuOOOaxz72Mc+lk996lPZZZdd8uyzz+Y3v/lNfvrTn6ampnWji2eeeSbnn39+kmSHHXbI/fffn169ejU+32+//XLIIYfk8MMPz6JFi3LqqafmL3/5S+PzBQsW5LbbbkuSnHnmmavsYEqSYcOG5cc//nFmzJhRMn7zzTdn6dKl6dGjRx566KFsttlmJc/33nvvfOlLX8o777yT7t27t9ZXrgqBEwAAAAAAreqtt5JNN612FZU1bVqyySbVrmKF73znO6vs0inXVNi0suHDh+cXv/hFnnzyydxyyy0tCpw++9nPloRNy3Xt2jWnn356TjvttLz11lt5/vnn85GPfGSt12nKJZdc0tjO7rLLLisJm5Y79NBDc/LJJ+eyyy7LhAkT8sgjjzQGdDNmzMi7776bJNlnn33WuFbv3r1L7t94440ky8LC8rBpZfX19e/7+7RXrZi3AgAAAAAA7cGxxx7brPnFYjFvvPFGXnzxxTz77LONf/r165ckeeqpp9qsnp133rnx+tVXX23ROk25++67kyQf/vCHs/vuu6923pe//OVV3kmSPn36pEuXLkmSa665JosXL37fay9vYfj8889nwoQJzap7XSNwAgAAAACA9UjPnj3zwQ9+8H3NHT16dIYOHZr6+vpsscUW2WabbbLjjjs2/hk9enSSZPr06S2qadttt13ts5V3Bc2ePbtF65RbuHBhXnrppSRZY9iUJEOGDEltbW2S5Nlnn20c79q1a4466qgky1rkDR48ON/5zndy++235+23317jZ37xi19MbW1tFi5cmE984hMZNmxYfv3rX+fZZ59NsVhswTdrfwROAAAAAACwHmmqZVy5YrGYL33pSxk6dGhGjx79nkHP/PnzW1TTms4n6rTS4VdLlixp0TrlZs6c2Xi96Xv0eaytrU2fPn2SZJWzmC666KIMGzYsSdLQ0JDzzjsvhx9+ePr06ZNdd9015513Xt55551VPnPbbbfNDTfckI022iiLFy/OqFGj8tWvfjU77rhjNt100xx//PG5//77W/o12wVnOAEAAAAA0Kr69Fl2plFH8s+col3o3Lnze8654oorcvnllydJdtppp3zrW9/K7rvvnn79+qV79+6Nn3HCCSfkmmuuWS924xQKhbV+d8MNN8xtt92WCRMm5Kabbsq4cePy5JNPZsmSJXn00Ufz6KOP5n/+539yyy23ZI899ih593Of+1wOOuig/Pa3v81dd92V+++/P//4xz8yffr0XHvttbn22mtz4okn5oorrigJ39Y1AicAAAAAAFpVp07JJptUuwrW5De/+U2SZPDgwXnwwQezwQYbNDmvfKfPumajjTZqvH7zzTfXOHfx4sV56623kpS2+VvZbrvtlt122y3JsvZ/48aNy5VXXpk//OEPmTZtWj73uc/llVdeWeXvs76+PqeeempOPfXUJMkLL7yQW2+9Nb/85S/z+uuv56qrrsqQIUNyxhlnrPV3rbZ1NyoDAAAAAID1XEt25azJc889lyQ54ogjVhs2FYvFPP74422yfqV07do1W221VZLkL3/5yxrnPvHEE3n33XeTJDvssMN7fnZdXV2GDRuW3//+9/nmN7+ZJJk6dWrGjx//nu9ut912+d73vpeHH344PXr0SJLcdNNN7/leeyZwAgAAAACAdqpbt26N1wsXLmy1z128eHGSZO7cuaudc+utt2bq1Kmttma1HHTQQUmWhWwTJkxY7bzLLrtslXferwMPPLDxevr06e/7vQEDBmTrrbdu9nvtkcAJAAAAAADaqS222KLx+pVXXmm1z12+62fkyJFNts175ZVX8vWvf73V1qumr371q41nI5166qmZNWvWKnPGjBnTeKbVbrvtll133bXx2auvvpr77rtvjWuMGTOm8XrQoEGN17fcckvefvvt1b43adKk/PWvf13lvXWRM5wAAAAAAKCdGjJkSLp165YFCxbkBz/4QWprazNw4MDGAKVfv36rbYm3JieccEL+v//v/8vrr7+ePfbYI9/97nezww47ZMGCBbn33nvzv//7v1m4cGE+9rGPrfNt9XbccceceeaZOe+88/LUU0/lYx/7WL773e9myJAhmTt3bkaOHJlf/OIXWbJkSbp06ZL/+7//K3l/4sSJ2X///bP99tvnM5/5THbZZZf069cvybLA6Le//W1jO7yddtopu+++e+O7//u//5tjjz02hx9+eA444IBst912qa+vz8yZM/Poo4/ml7/8ZebPn58kOe200yr0N9I2BE4AAAAAANBO1dXV5Zvf/Gb++7//O48//ngOOeSQkudjx47Nfvvt1+zPPeOMM/KnP/0pY8aMyYsvvphTTjml5PkGG2yQq6++OqNHj17nA6ck+a//+q/MnTs3F198cV555ZWceuqpq8ypr6/PTTfdlJ122qnJz3j++efz/PPPr3aNbbfdNn/4wx9WOXdr3rx5+d3vfpff/e53Tb7XqVOn/PjHP86RRx75vr9PeyRwosO69NLkb39LJk5c9ufnP0/23LPaVQEAAAAAlPqv//qvbLXVVrn66qvz3HPP5Z133smSJUta9Jm1tbUZPXp0Lrnkklx99dV5/vnnUywW069fvxx00EE544wzsu2222b06NGt9C2qq1OnTvnVr36Vo48+Ov/3f/+X+++/P2+++Wa6du2aD37wgznssMPyrW99K5tssskq7+69994ZN25c7rrrrjz88MOZNGlS3nzzzSxYsCC9e/fORz/60Xz2s5/NSSedlK5du5a8e8MNN2TUqFEZN25cnn/++bzxxhuZPn16unXrloEDB2afffbJaaedlo985COV+qtoM4VisVisdhG0rcmTJ2fAgAFJlm3v69+/f5Urah923DF59tkV91demZx4YtXKAQAAAIB1wksvvZTFixenpqam8RwgoHrW5jfZFrlBpxZ/Aqyjttyy9H7ixOrUAQAAAAAA6zqBEx2WwAkAAAAAAFqHwIkOS+AEAAAAAACtQ+BEhyVwAgAAAACA1iFwosMaOLD0fuLEpFisTi0AAAAAALAuEzjRYZXvcJo3L5kxozq1AAAAAADAukzgRIfVt2/SqewX0NBQnVoAAAAAAGBdJnCiw6qpSfr1Kx1zjhMAAAAAADSfwIkOrbytnsAJAAAAAACaT+BEhyZwAgAAAACAlhM40aEJnAAAAAAAoOUETnRoAicAAAAAAGg5gRMd2sCBpfcCJwAAAAAAaD6BEx1a+Q6nqVOThQurUwsAAAAAAKyrBE50aOWBU5JMmVL5OgAAAAAAYF0mcKJDq69PNtywdKyhoTq1AAAAAADAukrgRIdXvsvJOU4AAAAAANA8Aic6PIETAAAAAAC0jMCJDk/gBAAAAAAALSNwosMTOAEAAAAArFmhUEihUMjZZ5+9yrNx48Y1Ph83btxar3H22Wc3fk5b1EnbEjjR4QmcAAAAAACgZQROdHgDB5beT5yYFIvVqQUAAAAAANZFNdUuAKqtfIfTvHnJjBlJnz7VqQcAAAAAYF2y3377peh/xd/h2eFEh9e3b9Kp7JegrR4AAAAAALx/Aic6vJqapF+/0rGGhurUAgAAAAAA6yKBE2TVtnp2OAEAAAAA1TRv3rzU1dWlUCjk2GOPfc/5Dz30UAqFQgqFQi6++OKSZzNnzsyIESNy3HHHZfvtt0/Pnj3TpUuXbL755vnkJz+ZSy+9NIsWLVrrWseNG9e49rhx41Y7b/Lkyfn617+eD37wg+nWrVv69u2bI444Inffffdar702li5dmmuvvTaHHXZYNt9883Tp0iWbbLJJ9t9//1x88cXv+Xfx+uuv53vf+14+9rGPpb6+PrW1tdlss82y44475otf/GKuvPLKzJo1q8l3//jHP+bII49M//7907Vr19TV1eWDH/xg9t577/zgBz/IhAkT2uIrV4QznCDLAqcHHlhxL3ACAAAAAKqpe/fuOfLII3Pttdfm1ltvzdy5c9OjR4/Vzr/uuuuSJDU1NfnCF75Q8mzIkCFpaKKt05tvvpkxY8ZkzJgx+fWvf53bb789m2++eet+kX+6//77M3To0JIgZurUqRk5cmRGjhyZs88+u03WLTdjxowcccQReWDlfxBOMn369IwbNy7jxo3LRRddlDvuuCMDBw5c5f2mvkeSTJs2LdOmTcuzzz6bG2+8MRtvvHGGDh3a+HzJkiX54he/mN/97ncl7y1atChz5szJ3//+94wfPz533HFHHn300Vb8xpUjcILY4QQAAAAAtD/HHntsrr322sydOze33nprjjnmmCbnLV68uDHI+OQnP5mNN9645PmSJUuy++67Z+jQoRkyZEg222yzLFq0KH//+99z7bXX5s4778wTTzyRo48+eo07lNbWxIkTG0OaTp065dRTT82//Mu/pL6+Pk8//XT+67/+K2effXZ22WWXVl97ZUuWLMnQoUPz0EMPJUn23XffnH766Rk0aFBef/31XHHFFbnlllvywgsv5MADD8yTTz6Znj17Nr6/cOHCHH300Zk1a1bq6ury1a9+Nfvvv3823XTTxr/PBx98MH/84x9XWfuSSy5p/G+011575Utf+lI+9KEPpUePHnnrrbfy9NNP584778w777zTpn8HbUngBBE4AQAAAECrWro0eeutaldRWX36JJ1a9xSbgw46KJtuummmTZuW66+/frWB0913351p06YlSZPt9+69995stdVWq4zvueeeOfbYYzNixIicfPLJue+++3LPPffkwAMPbNXvceaZZzbuCLr22mvzxS9+sfHZLrvsks9//vPZe++923xnz69//evGsOmEE07IlVdemUKhkCTZeeedM2zYsHz/+9/Pf/7nf+aVV17JT3/605x77rmN7z/wwAN5/fXXkyTXX399yQ6mJPn4xz+eL37xi/n5z3+eefPmlTy76aabkiS77757xo4dm5qa0njmoIMOyr/9279lxowZrfulK0jgBBE4AQAAAECreuutZNNNq11FZU2blmyySat+ZE1NTY466qj88pe/zJgxY/LWW2+lT58+q8xb3k6vZ8+e+fSnP73K86bCppUNHz48v/jFL/Lkk0/mlltuadXA6Y033mjc8TN06NCSsGm5urq6XHrppdl9991bbd2m/OpXv0qSbLLJJrnooosaw6aV/fjHP84f/vCH/PWvf81vfvOb/OQnP0nXrl2TLPsuy+2zzz6rXaempiYbbrhhydjyd/fcc89VwqaV9e7d+/1/oXamdeNWWEeVt+KcOjVZuLA6tQAAAAAALLd8x9K7777buEtmZfPnz88tt9ySJDnyyCPTvXv3NX5esVjMG2+8kRdffDHPPvts459+/folSZ566qlWrX/s2LFZsmRJkmXB1urstttu+fCHP9yqa6/s9ddfzwsvvJAk+cIXvpC6urom59XU1DTWOXPmzDz++OONz7bYYovG6xEjRjRr/eXvjhw5MtOnT2/Wu+sKgRNk1R1OSTJlSuXrAAAAAABY2e67754PfehDSVbsZFrZbbfdljlz5iRpup3ecqNHj87QoUNTX1+fLbbYIttss0123HHHxj+jR49OklYPQ5555pnG61133XWNc3fbbbdWXXtlzz77bOP1e+2kWvn5yu/ttdde+eAHP5gk+da3vpXddtst55xzTh544IEsWrRojZ954oknJklefvnlDB48OCeffHJuuOGGTJ48udnfpb0SOEGS+vqkbIejtnoAAAAAQLuwPEh68MEH89prr5U8Wx5CbbrppjnooINWebdYLOZLX/pShg4dmtGjR2f27NlrXGv+/PmtU/Q/rXwm0abv0WZxs802a9W117aOzTffvMn3amtrM3LkyGy33XZJkkceeSRnnXVW9tprr/Tq1SuHHnporr/++sYdXSs7+eSTc9ZZZ6WmpibvvPNORowYkWOOOSYDBgzI4MGDc+aZZ+bVV19t6desKmc4wT9tuWWyUlidhobq1QIAAAAA67Q+fZadadSRNHG2Ums59thj85Of/CTFYjE33HBD/v3f/z3JsjDkrrvuSpIcddRRTZ4NdMUVV+Tyyy9Pkuy000751re+ld133z39+vVL9+7d07lz5yTJCSeckGuuuSbFYrHNvkdTZyZVQ0vq2H777fPMM89k5MiRGTlyZP785z/n5Zdfzvz583PXXXflrrvuygUXXJDbb799lWDrZz/7WU499dRcd911ueeee/Lwww9n3rx5eeWVV3LBBRfkl7/8ZX7xi1/ktNNOa+lXrAqBE/xTeeBkhxMAAAAArKVOnZJNNql2FeuNrbfeOrvsskseffTRXH/99Y2B080339zYym117fR+85vfJEkGDx6cBx98MBtssEGT81beydOaNtpoo8brN998MwMGDFjt3DfffLNNakiS3r17v+913njjjSbfW65z58458sgjc+SRRyZJpk6dmjvvvDO/+tWv8thjj+Wxxx7LV77ylfzxj39c5d2BAwfmrLPOyllnnZV33303jzzySG666ab83//9XxYsWJCvfe1r2X333TNkyJC1/KbVo6Ue/FP5OU4CJwAAAACgvVgeKD377LN5+umnk6xop/ehD31otecSPffcc0mSI444YrVhU7FYzOOPP97aJSdJdtxxx8brRx55ZI1z3+t5S+ywww6N13/5y1/WOHfChAlNvrc6W2yxRYYPH56HHnooH/vYx5Iko0aNes/2hLW1tdlzzz3zv//7v7n++uuTLPtvcfPNN7/nmu2RwAn+SeAEAAAAALRXRx99dGP7u+uuuy6TJ0/O/fffn2T1u5uSZPHixUmSuXPnrnbOrbfemqlTp7ZitSvsv//+jXVfddVVq533yCOP5NmVW1C1sr59+zaevXTTTTdlzpw5Tc5bsmRJrrzyyiTLdmctD5Dej9ra2uy7775Jlv29v/322+/73QMPPLDxevr06e/7vfZE4AT/JHACAAAAANqrzTffPAcccECS5IYbbsj111/feN7SmgKnrbbaKkkycuTIJtvmvfLKK/n617/eBhUvs8UWW+TTn/50kuS2227LTTfdtMqcOXPm5Ctf+Uqb1bDc8u/5j3/8I9/85jebnPPjH/84zz//fJLky1/+crp27dr47P7778/LL7+82s9ftGhR7rvvviRJz549s8lKbSWvvfbaxvCvKWPGjGm8HjRo0Pv4Nu2PwAn+qanAqQ3PxwMAAAAAaJblwdKkSZNyzjnnJEl22WWXbL311qt954QTTkiSvP7669ljjz1yxRVXZMKECfnzn/+cs88+OzvvvHNmzJjRrJ08zXX++eenrq4uSXLMMcfk61//esaOHZvHHnssI0aMyM4775wnnngiu+yyS5vVkCSnnXZa9thjjyTJiBEjcuCBB+b3v/99Hn/88YwePTqf+9zn8tOf/jTJsjaFP/jBD0rev+eee7LNNttkv/32y3nnnZe77rorjz/+eB544IGMGDEie++9d2NrwlNOOSU1NTWN7x5//PHp379/vva1r+Xaa6/NQw89lCeeeCJ33nlnzjzzzMb/Tj179lxjgNie1bz3FOgYBg4svZ83L5kxI+nTpzr1AAAAAACs7LOf/Wy++tWvZv78+Y3t2t4rnDjjjDPypz/9KWPGjMmLL76YU045peT5BhtskKuvvjqjR49us3OcPvCBD+S2227LEUcckdmzZ+fiiy/OxRdfXDLnhz/8YQqFQh599NE2qSFJOnfunFGjRuWII47IAw88kHvvvTf33nvvKvO222673HHHHenZs+cqz5YuXZr77ruvcSdTUz796U83BoIre/PNN3PJJZfkkksuafK9+vr63HjjjRkwYEAzvlX7YYcT/FPfvkmnsl+EtnoAAAAAQHtRV1eXYcOGNd537tw5Rx999Brfqa2tzejRo/OLX/wiu+yyS7p3754NNtgggwcPzmmnnZbHH388n//859u69Oy333557rnn8tWvfjUDBw5Mly5dstlmm+Xwww/PnXfemR//+MdtXkOS9O7dO3/+859z9dVX59BDD81mm22W2tra9OnTJ/vtt18uuuiiPPnkkxlYvkMhybe//e38/ve/z1e/+tV8/OMfz5Zbbplu3bqlW7du+cAHPpAvfOELGTVqVG655ZZssMEGJe8+++yzOffcczNs2LBsv/326dOnTzp37pxevXrl4x//eH70ox/lb3/7Ww499NCK/D20hUKxqGnY+m7y5MmNieikSZPSv3//KlfUfm25ZTJp0or7W25J/tleFAAAAABI8tJLL2Xx4sWpqalpPB8IqJ61+U22RW5ghxOspPwcp4aG6tQBAAAAAADrEoETrKQ8cNJSDwAAAAAA3pvACVYicAIAAAAAgOYTOMFKBE4AAAAAANB8AidYicAJAAAAAACaT+AEKxk4sPR+6tRk4cLq1AIAAAAAAOsKgROspHyHU5JMmVL5OgAAAAAAYF0icIKV1NcnG25YOqatHgAAAAAArJnACcqU73JqaKhOHQAAAAAAsK4QOEGZ8sDJDicAAAAAAFgzgROUETgBAAAAALCuKBaL1S4hicAJViFwAgAAAIDV69y5c5Jk8eLFWbJkSZWrgY5tyZIljb/D5b/NahE4QRmBEwAAAACsXvfu3Ruv33777eoVApT8Blf+bVZDTVVXh3aoqcCpWEwKherUAwAAAADtSa9evTJz5swkybRp07JkyZJsuOGG6dq1awr+EQ3aXLFYzMKFCzNr1qy89dZbjeMbbbRRFasSOMEqBg4svZ83L5kxI+nTpzr1AAAAAEB70q1bt9TX1+edd95Jkrz11lt56623UigUqt7SCzqCJUuWrHJuU319fbp27VqlipYROEGZvn2TTp2SpUtXjE2cKHACAAAAgOW22GKLdOnSJf/4xz8ax4rFYhYvXlzFqqBj2mSTTdKnHfwDtsAJytTUJP36JZMmrRibODEZMqR6NQEAAABAe1IoFLLxxhtnww03zJw5czJ37twsWrQoS1f+X3EDbaJTp07p0qVLevTokZ49e6ZLly7VLimJwAmatOWWpYFTQ0P1agEAAACA9qpLly7p3bt3evfuXe1SgCrrVO0CoD3acsvS+4kTq1MHAAAAAACsCwRO0ASBEwAAAAAAvH8CJ2iCwAkAAAAAAN4/gRM0QeAEAAAAAADvn8AJmlAeOE2dmixcWJ1aAAAAAACgvRM4QRMGDlx1bMqUytcBAAAAAADrAoETNKG+Ptlww9IxbfUAAAAAAKBpAidYDec4AQAAAADA+yNwgtUoD5waGqpTBwAAAAAAtHcCJ1gNO5wAAAAAAOD9ETjBagicAAAAAADg/RE4wWoInAAAAAAA4P0ROMFqNBU4FYvVqQUAAAAAANozgROsRnngNG9eMmNGdWoBAAAAAID2TOAEq9GvX9Kp7BeirR4AAAAAAKxK4ASrUVOzLHRamcAJAAAAAABWJXCCNWjqHCcAAAAAAKCUwAnWoDxwamioTh0AAAAAANCeCZxgDexwAgAAAACA9yZwgjUQOAEAAAAAwHsTOMEaCJwAAAAAAOC9CZxgDcoDp6lTk4ULq1MLAAAAAAC0VwInWIPywClJpkypfB0AAAAAANCeCZxgDXr1SjbcsHRMWz0AAAAAACglcIL34BwnAAAAAABYM4ETvAeBEwAAAAAArJnACd5DeeDU0FCdOgAAAAAAoL0SOMF7sMMJAAAAAADWTOAE70HgBAAAAAAAayZwgvfQVOBULFanFgAAAAAAaI8ETvAeygOnefOSGTOqUwsAAAAAALRHAid4D/36JZ3Kfina6gEAAAAAwAoCJ3gPNTXLQqeVCZwAAAAAAGAFgRO8D02d4wQAAAAAACwjcErS0NCQM888M9tuu2169OiR3r17Z9ddd815552XefPmtcoaf//73/Ov//qv2WGHHVJXV5cePXpkq622yte+9rU899xzrbIGbac8cGpoqE4dAAAAAADQHtVUu4BqGzlyZI477rjMmjWrcWzevHl59NFH8+ijj+ayyy7L6NGjM3jw4LVe49JLL803vvGNLFq0qGT85Zdfzssvv5zLL788559/fk4//fS1XoO2ZYcTAAAAAACsXofe4fTEE0/kqKOOyqxZs9KzZ8/87Gc/y4MPPph77rknX/7yl5MkL774Yg4//PDMnj17rda48cYb85WvfCWLFi1KfX19fvKTn2T8+PF55JFHcumll2bw4MFZtGhRvvnNb+amm25qza9HKxI4AQAAAADA6hWKxWKx2kVUyz777JP7778/NTU1+fOf/5w99tij5Pl5552X73znO0mSH/3oRzn77LOb9fnz5s3LoEGDMm3atPTs2TMPPfRQdthhh5I5s2bNyl577ZVnnnkmm222WV5++eX07NmzRd+r3OTJkzNgwIAkyaRJk9K/f/9W/fyOYNSoZNiwFfdbbJG8/nr16gEAAAAAgLXVFrlBh93hNGHChNx///1JklNOOWWVsClJzjzzzGy33XZJkgsvvDDvvvtus9a4/fbbM23atCTJGWecsUrYlCQbbrhhLrjggiTJm2++mSuvvLJZa1AZ5Tucpk5NFi6sTi0AAAAAANDedNjA6ZZbbmm8Hj58eJNzOnXqlBNOOCFJ8vbbb2fs2LHNWuPRRx9tvP7Upz612nn77bdfunXrliS5+eabm7UGlVEeOCXJlCmVrwMAAAAAANqjDhs4jR8/PknSo0eP7Lzzzqudt++++zZeP/DAA81a46233mq83myzzVY7r6amJr17906SPPTQQ1m8eHGz1qHt9eqVbLhh6ZhznAAAAAAAYJmaahdQLS+88EKSZPDgwampWf1fw7bbbrvKO+/XymcxvfPOO6udVywWM2vWrCTJokWL8vLLL5es+14mT568xudTp05935/F6m25ZfLssyvuBU4AAAAAALBMhwycFixYkOnTpyfJex6EtdFGG6VHjx6ZO3duJk2a1Kx1lp//lCT33XffandSPfHEE5kzZ07j/cSJE5sVOC0/2Iu2JXACAAAAAICmdciWerNnz268XnkX0ur06NEjSUpCoffjU5/6VOPuqQsuuKAx5FrZ0qVL8/3vf3+19dF+lJ/j1NBQnToAAAAAAKC96ZCB04IFCxqvu3Tp8p7zu3btmiSZP39+s9YZMGBATjvttCTJlClT8olPfCK33nprZs2alQULFuThhx/OYYcdljvvvLOkjuauM2nSpDX+mTBhQrM+j6aVB052OAEAAAAAwDIdsqVet27dGq8XLVr0nvMXLlyYJNlggw2avdb//M//5NVXX83tt9+eF198MUceeeQqc3bZZZfsuuuuueSSS5IkdXV1zVrjvdoC0joETgAAAAAA0LQOucNp5UDn/bTJmzt3bpL3136vXNeuXTNy5Mj85je/yU477ZRCodD4bNNNN833v//93H///SkWi43jG220UbPXoe01FTit9J8NAAAAAAA6rA67w6lPnz556623Mnny5DXOnTlzZmPgNGDAgLVar1OnTvnSl76UL33pS5k9e3befPPNdO/ePZtvvnk6dVqW+b300kuN87fffvu1Woe2VR44zZuXzJiR9OlTnXoAAAAAAKC96JA7nJIVoc7LL7+cxYsXr3beX//618br7bbbrsXr1tXVZfDgwenbt29j2LRkyZI8+eSTSZIPfvCD2XjjjVu8Dq2vb9+kU9kvRls9AAAAAADowIHTXnvtlWRZu7zHHntstfPuu+++xutPfOITbVLL2LFj89ZbbyVJjjrqqDZZg5arrU369SsdEzgBAAAAAEAHDpyOPPLIxusRI0Y0OWfp0qW5+uqrkyS9evXK/vvv3+p1FIvFnH322UmS2trafPnLX271NWg9TZ3jBAAAAAAAHV2HDZx222237L333kmSyy+/PA899NAqc84///y88MILSZIzzjgjtbW1Jc/HjRuXQqGQQqGQk046qcl13nrrrSxcuLDJZ0uWLMnpp5+eBx54IEny7//+7xk0aNDafiUqQOAEAAAAAACrqql2AdV04YUX5hOf+ETmz5+fQw45JGeddVb233//zJ8/PzfeeGMuvfTSJMnWW2+dM888c63WGDt2bE4//fQcffTR2XfffbPllltmwYIFefrpp3PppZc2nt30qU99Kt///vdb66vRRsoDp4aG6tQBAAAAAADtSYcOnIYMGZLf/va3Oe644zJr1qycddZZq8zZeuutM3r06NTV1a31Om+++WYuvPDCXHjhhas8KxQKGT58eC6++OJ06dJlrdegMuxwAgAAAACAVXXowClJhg0blqeffjoXXnhhRo8encmTJ6dLly4ZPHhwPv/5z+f0009P9+7d1/rz995775x33nm5995789e//jVvvvlmOnXqlL59+2b//ffP8OHDs/vuu7fiN6ItCZwAAAAAAGBVhWKxWKx2EbStyZMnZ8CAAUmSSZMmpX///lWuaN319NPJRz9aOrZgQdK1a3XqAQAAAACA5mqL3KBTiz8BOpDyHU5JMmVK5esAAAAAAID2ROAEzVBfn5Qf56WtHgAAAAAAHZ3ACZqhUEgGDiwdEzgBAAAAANDRCZygmcrb6gmcAAAAAADo6ARO0EwCJwAAAAAAKCVwgmYqD5waGqpTBwAAAAAAtBcCJ2gmO5wAAAAAAKCUwAmaqanAqVisTi0AAAAAANAeCJygmcoDp3nzkhkzqlMLAAAAAAC0BwInaKa+fZNOZb8cbfUAAAAAAOjIBE7QTLW1Sb9+pWMCJwAAAAAAOjKBE6yFps5xAgAAAACAjkrgBGtB4AQAAAAAACsInGAtCJwAAAAAAGAFgROshfLAqaGhOnUAAAAAAEB7IHCCtWCHEwAAAAAArCBwgrVQHjhNnZosXFidWgAAAAAAoNoETrAWygOnJJkypfJ1AAAAAABAeyBwgrVQX5/U1ZWOaasHAAAAAEBHJXCCtVAoJAMHlo4JnAAAAAAA6KgETrCWytvqCZwAAAAAAOioBE6wlgROAAAAAACwjMAJ1lJ54NTQUJ06AAAAAACg2gROsJbscAIAAAAAgGUETrCWmgqcisXq1AIAAAAAANUkcIK1VB44zZuXzJhRnVoAAAAAAKCaBE6wlvr2TTqV/YK01QMAAAAAoCMSOMFaqq1dFjqtTOAEAAAAAEBHJHCCFhg4sPRe4AQAAAAAQEckcIIWKD/HSeAEAAAAAEBHJHCCFhA4AQAAAACAwAlapDxwamioTh0AAAAAAFBNAidoATucAAAAAABA4AQtUh44TZ2aLFxYnVoAAAAAAKBaBE7QAuWBU5JMmVL5OgAAAAAAoJoETtAC9fVJXV3pmLZ6AAAAAAB0NAInaIFCwTlOAAAAAAAgcIIWGjiw9F7gBAAAAABARyNwghaywwkAAAAAgI5O4AQtJHACAAAAAKCjEzhBC5UHTg0N1akDAAAAAACqReAELdTUDqdisTq1AAAAAABANQicoIXKA6d585IZM6pTCwAAAAAAVIPACVqob9+kU9kvyTlOAAAAAAB0JAInaKHa2mWh08oETgAAAAAAdCQCJ2gFAweW3gucAAAAAADoSARO0ArKz3ESOAEAAAAA0JEInKAVCJwAAAAAAOjIBE7QCgROAAAAAAB0ZAInaAXlgVNDQ3XqAAAAAACAahA4QSsoD5ymTk0WLqxOLQAAAAAAUGkCJ2gF5YFTkkyZUvk6AAAAAACgGgRO0Arq65O6utIx5zgBAAAAANBRCJygFRQKq+5yEjgBAAAAANBRCJyglQwcWHovcAIAAAAAoKMQOEErscMJAAAAAICOSuAErUTgBAAAAABARyVwglYicAIAAAAAoKMSOEErKQ+cGhqSYrE6tQAAAAAAQCUJnKCVlAdO8+YlM2ZUpxYAAAAAAKgkgRO0kr59k05lvyht9QAAAAAA6AgETtBKamuXhU4rEzgBAAAAANARCJygFZW31RM4AQAAAADQEQicoBUNHFh6L3ACAAAAAKAjEDhBK7LDCQAAAACAjkjgBK1I4AQAAAAAQEckcIJWVB44NTRUpw4AAAAAAKgkgRO0ovLAaerUZOHC6tQCAAAAAACVInCCVlQeOCXJlCmVrwMAAAAAACpJ4AStqL4+qasrHXOOEwAAAAAA6zuBE7SiQmHVXU4CJwAAAAAA1ncCJ2hlAicAAAAAADoagRO0soEDS+8FTgAAAAAArO8ETtDK7HACAAAAAKCjEThBKxM4AQAAAADQ0QicoJWVB04NDUmxWJ1aAAAAAACgEgRO0MrKA6d585IZM6pTCwAAAAAAVILACVpZ375Jp7JflrZ6AAAAAACszwRO0Mpqa5eFTisTOAEAAAAAsD4TOEEbKG+rJ3ACAAAAAGB9JnCCNjBwYOm9wAkAAAAAgPWZwAnagB1OAAAAAAB0JAInaAMCJwAAAAAAOhKBE7QBgRMAAAAAAB2JwAnaQHngNHVqsmhRdWoBAAAAAIC2JnCCNlAeOBWLyeTJ1akFAAAAAADamsAJ2kB9fVJXVzqmrR4AAAAAAOsrgRO0gULBOU4AAAAAAHQcAidoIwInAAAAAAA6CoETtJGBA0vvBU4AAAAAAKyvBE7QRuxwAgAAAACgoxA4QRsROAEAAAAA0FEInKCNNBU4FYvVqQUAAAAAANqSwAnaSHngNHduMmNGdWoBAAAAAIC2JHCCNtK3b9Kp7BemrR4AAAAAAOsjgRO0kdraZaHTygROAAAAAACsjwRO0IaaOscJAAAAAADWNwInaEMCJwAAAAAAOgKBE7ShgQNL7wVOAAAAAACsjwRO0IbscAIAAAAAoCMQOEEbEjgBAAAAANARCJygDZUHTlOnJosWVacWAAAAAABoKwInaEPlgVOxmEyeXJ1aAAAAAACgrQicoA3V1yd1daVj2uoBAAAAALC+EThBGyoUnOMEAAAAAMD6T+AEbUzgBAAAAADA+k7gBG1M4AQAAAAAwPpO4ARtbODA0nuBEwAAAAAA6xuBE7QxO5wAAAAAAFjfCZygjTUVOBWL1akFAAAAAADagsAJ2lh54DR3bjJjRnVqAQAAAACAtiBwgjbWt2/SqeyXpq0eAAAAAADrE4ETtLHa2mWh08oETgAAAAAArE8ETlABTZ3jBAAAAAAA6wuBE1SAwAkAAAAAgPWZwAkqYODA0nuBEwAAAAAA6xOBU5KGhoaceeaZ2XbbbdOjR4/07t07u+66a84777zMmzevVdZ47bXX8t3vfjc777xzevXqldra2vTu3Tt77rlnfvKTn2TatGmtsg7tkx1OAAAAAACszwrFYrFY7SKqaeTIkTnuuOMya9asJp9vvfXWGT16dAYPHrzWa1xzzTX5yle+kvnz5692Tu/evXPjjTfm4IMPXut1Vmfy5MkZMGBAkmTSpEnp379/q6/Bmo0alQwbtuK+b99kypTq1QMAAAAAQMfVFrlBh97h9MQTT+Soo47KrFmz0rNnz/zsZz/Lgw8+mHvuuSdf/vKXkyQvvvhiDj/88MyePXut1njggQdy0kknZf78+enUqVOGDx+eW265JRMmTMjNN9+cYf9MIWbMmJFPf/rTefXVV1vt+9F+lO9wmjo1WbSoOrUAAAAAAEBr69CB0xlnnJH58+enpqYmY8aMyVlnnZU99tgjBxxwQC699NL893//d5JlodP555+/Vmucc845Wbp0aZLkl7/8Za644op8+tOfzq677prPfe5zue222/Jv//ZvSZL58+fnggsuaJ0vR7tSHjgVi8nkydWpBQAAAAAAWluHDZwmTJiQ+++/P0lyyimnZI899lhlzplnnpntttsuSXLhhRfm3XffbfY6Dz74YJKkT58++drXvtbknB/+8IeN1w899FCz16D9q69P6upKx5zjBAAAAADA+qLDBk633HJL4/Xw4cObnNOpU6eccMIJSZK33347Y8eObfY6i/7ZN23QoEGrnVNfX5+NN964ZD7rl0Jh1V1OAicAAAAAANYXHTZwGj9+fJKkR48e2XnnnVc7b9999228fuCBB5q9zjbbbJMk+fvf/77aObNmzcr06dNL5rP+ETgBAAAAALC+6rCB0wsvvJAkGTx4cGpqalY7b9ttt13lneY47bTTkiRvvfVWfv3rXzc556c//ekq81n/CJwAAAAAAFhfrT5pWY8tWLCgcUdR//791zh3o402So8ePTJ37txMmjSp2WudfPLJGT9+fK6++up8/etfz2OPPZYjjjgiW2yxRSZOnJhrrrmmsb3f97///Rx00EHNXmPy5MlrfD516tRmfyatb+DA0nuBEwAAAAAA64sOGTjNnj278bpnz57vOX954DRnzpxmr9W5c+dcddVVGTZsWP7zP/8zl112WS677LKSOfvvv3/OOuustQqbkmTAgAFr9R6VZYcTAAAAAADrqw7ZUm/BggWN1126dHnP+V27dk2SzJ8/f63We+GFF3L11VfnmWeeafL5Qw89lMsvvzxTpkxZq89n3dBU4FQsVqcWAAAAAABoTR0ycOrWrVvj9aJFi95z/sKFC5MkG2ywQbPXuv/++7PHHntk5MiR6devX6655pq88cYbWbRoUSZNmpRf/epX6d69e2688cbstttuee6555q9xqRJk9b4Z8KECc3+TFpfeeA0d24yc2Z1agEAAAAAgNbUIVvq1dXVNV6/nzZ5c+fOTfL+2u+tbOHChfniF7+Yd955J5tvvnkefvjhbL755o3P+/fvn6997WvZd999s8suu+T111/PiSeemEcffbRZ67zXOVS0D337Jp06JUuXrhhraEh6965eTQAAAAAA0Bo67A6nPn36JEkmT568xrkzZ85sDJyae1bSnXfe2dgm7xvf+EZJ2LSyD3/4wznuuOOSJI899lieeuqpZq3DuqG2dlnotDLnOAEAAAAAsD7okIFTkmy//fZJkpdffjmLFy9e7by//vWvjdfbbbdds9Z44YUXGq8/9rGPrXHuzjvv3OSarF+aOscJAAAAAADWdR02cNprr72SLGuX99hjj6123n333dd4/YlPfKJZa9TUrOhYuKZQK0nefffdJt9j/SJwAgAAAABgfdRhA6cjjzyy8XrEiBFNzlm6dGmuvvrqJEmvXr2y//77N2uNQYMGNV7ff//9a5y7crC18nusXwROAAAAAACsjzps4LTbbrtl7733TpJcfvnleeihh1aZc/755ze2xTvjjDNSW1tb8nzcuHEpFAopFAo56aSTVnn/wAMPTPfu3ZMkl1xySZ555pkma7njjjvyxz/+MUnSr1+/7LTTTmv7tWjnBg4svRc4AQAAAACwPuiwgVOSXHjhhdlggw2yePHiHHLIITnnnHPy8MMPZ+zYsfnKV76S73znO0mSrbfeOmeeeWazP79Xr1753ve+lySZPXt29txzz5x11lkZO3Zsnnzyydx111352te+liOOOCJLly5NkvzXf/1XOnXq0P9Z1mt2OAEAAAAAsD7q0IcFDRkyJL/97W9z3HHHZdasWTnrrLNWmbP11ltn9OjRqaurW6s1/uM//iMzZszIhRdemDlz5uScc87JOeecs8q82tra/Od//meOO+64tVqHdUN54DR1arJoUdKlS3XqAQAAAACA1tDht9IMGzYsTz/9dP71X/81W2+9dbp3755evXpll112ybnnnpsnnngigwcPXuvPLxQK+fnPf55HHnkkp512WnbYYYfU1dWlc+fOqa+vz84775x/+7d/y7PPPptvf/vbrfjNaI/KA6diMZkypTq1AAAAAABAaykUi8VitYugbU2ePDkDBgxIkkyaNCn9+/evckUdV7GY1Ncns2evGBs7Ntlvv6qVBAAAAABAB9MWuUGH3+EElVQoOMcJAAAAAID1j8AJKkzgBAAAAADA+kbgBBUmcAIAAAAAYH0jcIIKEzgBAAAAALC+EThBhQ0cWHovcAIAAAAAYF0ncIIKa2qHU7FYnVoAAAAAAKA1CJygwsoDp7lzk5kzq1MLAAAAAAC0BoETVFjfvkmnsl+etnoAAAAAAKzLBE5QYbW1y0KnlTU0VKcWAAAAAABoDQInqIKmznECAAAAAIB1lcAJqkDgBAAAAADA+kTgBFUgcAIAAAAAYH0icIIqEDgBAAAAALA+EThBFQwcWHovcAIAAAAAYF0mcIIqKN/hNHVqsmhRdWoBAAAAAICWEjhBFZQHTsViMmVKdWoBAAAAAICWEjhBFdTXJ3V1pWPa6gEAAAAAsK4SOEEVFAqr7nJqaKhOLQAAAAAA0FICJ6iS8sDJDicAAAAAANZVAieoEoETAAAAAADrC4ETVInACQAAAACA9YXACapk4MDSe4ETAAAAAADrKoETVElTO5yKxerUAgAAAAAALSFwgiopD5zmzk1mzqxOLQAAAAAA0BICJ6iSvn2TTmW/QG31AAAAAABYFwmcoEpqa5eFTitraKhOLQAAAAAA0BICJ6iips5xAgAAAACAdY3ACapI4AQAAAAAwPpA4ARVJHACAAAAAGB9IHCCKhI4AQAAAACwPhA4QRUNHFh6L3ACAAAAAGBdJHCCKirf4TR1arJoUXVqAQAAAACAtSVwgioqD5yKxWTKlOrUAgAAAAAAa0vgBFVUX5/U1ZWOaasHAAAAAMC6RuAEVVQorLrLqaGhOrUAAAAAAMDaEjhBlZUHTnY4AQAAAACwrhE4QZUJnAAAAAAAWNcJnKDKBE4AAAAAAKzrBE5QZQInAAAAAADWdQInqLKBA0vvJ05MisXq1AIAAAAAAGtD4ARVVr7Dae7cZObM6tQCAAAAAABrQ+AEVda3b9Kp7JeorR4AAAAAAOsSgRNUWW3tstBpZQInAAAAAADWJQInaAfK2+o1NFSnDgAAAAAAWBsCJ2gHygMnO5wAAAAAAFiXCJygHRA4AQAAAACwLhM4QTsgcAIAAAAAYF0mcIJ2QOAEAAAAAMC6TOAE7cDAgaX3U6cmixZVpxYAAAAAAGgugRO0A+U7nIrFZMqU6tQCAAAAAADNJXCCdqC+PqmrKx3TVg8AAAAAgHWFwAnagULBOU4AAAAAAKy7BE7QTpQHTg0N1akDAAAAAACaS+AE7YQdTgAAAAAArKsETtBOCJwAAAAAAFhXCZygnRA4AQAAAACwrhI4QTsxcGDp/cSJSbFYnVoAAAAAAKA5BE7QTpTvcJo7N5k5szq1AAAAAABAcwicoJ3o2zfpVPaL1FYPAAAAAIB1gcAJ2ona2mWh08oETgAAAAAArAsETtCOlLfVEzgBAAAAALAuEDhBO1IeODU0VKcOAAAAAABoDoETtCN2OAEAAAAAsC4SOEE7InACAAAAAGBdJHCCdkTgBAAAAADAukjgBO3IwIGl91OnJosWVacWAAAAAAB4vwRO0I6U73AqFpMpU6pTCwAAAAAAvF8CJ2hH6uuTurrSMW31AAAAAABo7wRO0I4UCs5xAgAAAABg3SNwgnamPHBqaKhOHQAAAAAA8H4JnKCdscMJAAAAAIB1jcAJ2hmBEwAAAAAA6xqBE7QzAicAAAAAANY1AidoZ5oKnIrF6tQCAAAAAADvh8AJ2pmBA0vv585NZs6sTi0AAAAAAPB+CJygnenbN+lU9svUVg8AAAAAgPZM4ATtTG3tstBpZQInAAAAAADaM4ETtENNneMEAAAAAADtlcAJ2qHywKmhoTp1AAAAAADA+yFwgnbIDicAAAAAANYlAidohwROAAAAAACsSwRO0A4JnAAAAAAAWJcInKAdKg+cpk5NFi2qTi0AAAAAAPBeBE7QDg0cWHpfLCZTplSnFgAAAAAAeC8CJ2iH6uuTurrSMW31AAAAAABorwRO0A4VCs5xAgAAAABg3SFwgnZK4AQAAAAAwLpC4ATtVHng1NBQnToAAAAAAOC9CJygnbLDCQAAAACAdYXACdopgRMAAAAAAOsKgRO0U00FTsVidWoBAAAAAIA1EThBOzVwYOn93LnJzJnVqQUAAAAAANZE4ETHNn9+cvvtyY9+VO1KVtG3b9Kp7BeqrR4AAAAAAO2RwImO6a23kk9/Otl44+Tww5Of/CR55ZVqV1WitnZZ6LQygRMAAAAAAO2RwImOaaONkocfTubNWzE2alT16lmNps5xAgAAAACA9kbgRMfUqdOynU0rGzmyOrWsgcAJAAAAAIB1gcCJjmvo0NL7++5L3nmnOrWsRnng1NBQnToAAAAAAGBNBE50XIccknTpsuJ+8eJkzJjq1dMEO5wAAAAAAFgXCJzouHr2TPbfv3SsnbXVEzgBAAAAALAuEDjRsZW31bv99mTJkurU0oTywGnq1GTRourUAgAAAAAAqyNwomMbNqz0/q23kocfrk4tTRg4sPS+WEymTKlOLQAAAAAAsDoCJzq2gQOTHXcsHWtHbfXq65O6utIxbfUAAAAAAGhvBE5Q3lavHQVOhYJznAAAAAAAaP8ETlDeVu/555NXX61OLU0QOAEAAAAA0N4JnGC33ZJNNikdGzWqOrU0QeAEAAAAAEB7J3CCzp2Tww4rHWtHbfXKA6eGhurUAQAAAAAAqyNwgmTVtnr33ZfMmlWdWsrY4QQAAAAAQHsncIIkOeSQpLZ2xf277yZjxlSvnpU0FTgVi9WpBQAAAAAAmiJwgiSpq0v22690rJ2c41QeOM2dm8ycWZ1aAAAAAACgKQInWK68rd7o0cmSJdWpZSX9+iWdyn6p2uoBAAAAANCeCJxguaFDS++nT0/+8pfq1LKS2tqkb9/SMYETAAAAAADticAJlhs0KPnwh0vH2mlbPYETAAAAAADticAJVlbeVm/kyOrUUUbgBAAAAABAeyZwgpWVB07PPpu89lpVSllZeeDU0FCdOgAAAAAAoCkCJ1jZ7rsnG29cOtYO2urZ4QQAAAAAQHsmcIKVde6cHHZY6Vg7aKsncAIAAAAAoD0TOCVpaGjImWeemW233TY9evRI7969s+uuu+a8887LvHnz1vpzX3vttRQKhWb9+cAHPtB6X4y1U95Wb9y4ZPbsqpSyXHngNHVqsmhRdWoBAAAAAIByHT5wGjlyZD7ykY/kggsuyN/+9rfMmzcvM2fOzKOPPprvfOc7GTJkSF5++eWK1bPNNttUbC1W45BDktraFfeLFiV/+lP16smqgVOxmEyZUp1aAAAAAACgXE21C6imJ554IkcddVTmz5+fnj175t///d+z//77Z/78+bnxxhvzm9/8Ji+++GIOP/zwPProo6mrq2vW5/fr1y/PPPPMe84755xzcv311ydJTjzxxLX6LrSiDTdM9t03ufvuFWMjRyaf/WzVSurVK6mrK91oNXFiMmhQ1UoCAAAAAIBGHTpwOuOMMzJ//vzU1NRkzJgx2WOPPRqfHXDAAdlqq63yne98Jy+++GLOP//8nH322c36/Nra2uywww5rnLNkyZKMGzcuSVJXV5fPfOYzzf0atIWhQ0sDp9GjkyVLlp3xVAWFwrJdTs89t2LMOU4AAAAAALQXHbal3oQJE3L//fcnSU455ZSSsGm5M888M9ttt12S5MILL8y7777b6nXcfffdef3115Mk//Iv/5INNtig1ddgLZSf4/SPfySPPFKdWv6pvK2ewAkAAAAAgPaiwwZOt9xyS+P18OHDm5zTqVOnnHDCCUmSt99+O2PHjm31Oq6++urGa+302pEPfjDZfvvSsZEjq1PLPwmcAAAAAABorzps4DR+/PgkSY8ePbLzzjuvdt6+++7beP3AAw+0ag2zZ89uDL4+8IEPZJ999mnVz6eFhg4tvW9ngVNDQ3XqAAAAAACAch02cHrhhReSJIMHD05NzeqPstp2221Xeae13HzzzZk3b16S5Pjjj0+hUGjVz6eFytvqPfNMVVMeO5wAAAAAAGivVp+0rMcWLFiQ6dOnJ0n69++/xrkbbbRRevTokblz52bSpEmtWsfK7fSWt+5bG5MnT17j86lTp671Z3doe+yR9O6dzJixYmzUqOTrX69KOU0FTsViIqcEAAAAAKDaOmTgNHv27Mbrnj17vuf85YHTnDlzWq2GiRMn5r777kuS7Lnnnhk8ePBaf9aAAQNaqyxW1rlzcthhybXXrhgbObLdBE5z5yYzZy7LxAAAAAAAoJo6ZEu9BQsWNF536dLlPed37do1STJ//vxWq+Haa69NsVhM0rLdTbSx8rZ6Y8cmrRg8Nke/fkmnsl+stnoAAAAAALQHHXKHU7du3RqvFy1a9J7zFy5cmCTZYIMNWq2Ga665JsmyMOuoo45q0We9V6u/qVOnZrfddmvRGh3WJz+Z1NQkixcvu1+0KPnTn5LPfKbipdTWJn37Jit3UJw4Mdlpp4qXAgAAAAAAJTpk4FRXV9d4/X7a5M2dOzfJ+2u/935MmDAhf/3rX5MkRxxxRHr16tWiz3uvc6hogfr6ZJ99knvvXTE2cmRVAqdkWVu98sAJAAAAAACqrUO21OvWrVv69OmTJJm88r/eN2HmzJmNgVNrnZV09dVXN15rp7cOKG+rN3p0snRpVUopP8dJ4AQAAAAAQHvQIQOnJNl+++2TJC+//HIWL2+X1oTlO5GSZLvttmvxuu+++25uvPHGJMmmm26aQw89tMWfSRsrD5ymTUseeaQqpQicAAAAAABojzps4LTXXnslWdYu77HHHlvtvPvuu6/x+hOf+ESL1x09enTeeuutJMkxxxyTmpoO2dVw3fKhDyXbbls6NnJkVUopD5waGqpSBgAAAAAAlOiwgdORRx7ZeD1ixIgm5yxdurSx/V2vXr2y//77t3jdldvpnXjiiS3+PCqkfJfTqFFVKcMOJwAAAAAA2qMOGzjttttu2XvvvZMkl19+eR566KFV5px//vl54YUXkiRnnHFGamtrS56PGzcuhUIhhUIhJ5100nuuOWPGjIwePTpJsuOOO2annXZq2ZegcsoDp6eeqkraUx44TZ2aLFpU8TIAAAAAAKBEhw2ckuTCCy/MBhtskMWLF+eQQw7JOeeck4cffjhjx47NV77ylXznO99Jkmy99dY588wzW7zejTfemEX/TAfsblrH7LFHstFGpWNV2OVUHjgVi8mUKRUvAwAAAAAASnTowGnIkCH57W9/mw033DBz5szJWWedlT322CMHHHBALr300iTLwqbRo0enrq6uxestb6fXuXPnHHvssS3+PCqopiY57LDSsSoETr16JeX/p6itHgAAAAAA1dahA6ckGTZsWJ5++un867/+a7beeut07949vXr1yi677JJzzz03TzzxRAYPHtzidV566aX85S9/SZIcfPDB2XzzzVv8mVRYeVu9e+9N5s6taAmFgnOcAAAAAABof2qqXUB7MHDgwFxwwQW54IILmvXefvvtl2Kx+L7mbrXVVu97Lu3UJz+5bKfT4sXL7hcuTO6+O/n0pytaxpZbJs89t+Je4AQAAAAAQLV1+B1O8L716pXsvXfp2MiRFS/DDicAAAAAANobgRM0R3lbvVGjkqVLK1qCwAkAAAAAgPZG4ATNMXRo6f2bbyaPPVbREsoDp4aGii4PAAAAAACrEDhBc2y1VbLNNqVjFW6r19QOJ8eDAQAAAABQTQInaK7ytnpVDpzmzk1mzqxoCQAAAAAAUELgBM1V3lbvySeTyZMrtny/fkmnsl+uc5wAAAAAAKgmgRM01yc+kWy0UenYqFEVW762Nunbt3RM4AQAAAAAQDUJnKC5amqST32qdKwdnOMEAAAAAADVInCCtVHeVu+ee5YdplQhAicAAAAAANoTgROsjUMPTTp3XnG/cOGy0KlCBE4AAAAAALQnAidYGxttlOy9d+lYBdvqCZwAAAAAAGhPBE6wtsrb6o0enSxdWpGlywOnhoaKLAsAAAAAAE0SOMHaGjas9H7q1OTxxyuydHngNHVqsmhRRZYGAAAAAIBVCJxgbW299bI/K6tQW73ywKlYTKZMqcjSAAAAAACwCoETtER5W71RoyqybK9eSc+epWPOcQIAAAAAoFoETtAS5W31Hn+8IluNCoVk4MDSMYETAAAAAADVInCClvjEJ5ZtN1pZhXY5lbfVEzgBAAAAAFAtAidoidra5NBDS8cETgAAAAAAdDACJ2ip8rZ6d9+dzJvX5ssKnAAAAAAAaC8ETtBShx6adO684n7BguSee9p82fLAqaGhzZcEAAAAAIAmCZygpXr3XnaW08oq0FavqR1OxWKbLwsAAAAAAKsQOEFrKG+rN2pUm6c/AweW3s+dmzz2WJsuCQAAAAAATRI4QWsYOrT0/vXXk8cfb9Mlt9wyGTSodGzEiDZdEgAAAAAAmiRwgtawzTbJ4MGlY23cVq9QSE48sXTs+uuXHSEFAAAAAACVJHCC1lAorNpWb+TINl+2PHB6++3k1lvbfFkAAAAAACghcILWUt5W77HHlrXWa0Mf+EBywAGlY9rqAQAAAABQaQInaC17753U15eOjR7d5ssOH156P2ZMMnlymy8LAAAAAACNBE7QWmprk0MPLR2rQFu9z3422XDDFffFYnL11W2+LAAAAAAANBI4QWsqb6t3993J/PltumT37slRR5WOjRixLHgCAAAAAIBKEDhBa/rUp5JOK/2s5s9P7r23zZctb6v38svJAw+0+bIAAAAAAJBE4AStq0+f5BOfKB2rQFu9j3882Wab0rErrmjzZQEAAAAAIInACVpfeVu9UaPavL9doZCcfHLp2E03JXPmtOmyAAAAAACQROAErW/YsNL7KVOSJ59s82WPPz7p3HnF/dy5yc03t/myAAAAAAAgcIJWt+22yYc+VDpWgbZ6W2yRHHpo6diIEW2+LAAAAAAACJyg1RUKTbfVq4Dhw0vv//zn5JVXKrI0AAAAAAAdmMAJ2kJ5W71HHkmmTq3Isn36lI5deWWbLwsAAAAAQAcncIK2sPfeyYYblo6NHt3my3bpkhx7bOnYVVclS5a0+dIAAAAAAHRgAidoC126JJ/8ZOlYldrqTZqU3HtvRZYGAAAAAKCDEjhBWylvq/enPyULFrT5sjvttOzPykaMaPNlAQAAAADowARO0FY+9amk00o/sXnzKrbVqHyX0x//mLz9dkWWBgAAAACgAxI4QVvZeONkjz1KxyrUVu+YY5La2hX3CxYkN95YkaUBAAAAAOiABE7Qlsrb6o0alRSLbb7sxhsnRxxROqatHgAAAAAAbUXgBG2pPHCaNCl56qmKLF3eVm/ChOS55yqyNAAAAAAAHYzACdrSdtslgwaVjlWord4nP5lssUXpmF1OAAAAAAC0BYETtKVCYdVdTiNHVmTpmprk+ONLx665Jnn33YosDwAAAABAByJwgrZWHjhNmJC88UZFli5vqzdtWnLHHRVZGgAAAACADkTgBG1tn32SurrSsdtvr8jS226b7LFH6Zi2egAAAAAAtDaBE7S1Ll2WHai0sgq11UtW3eU0atSynU4AAAAAANBaBE5QCeVt9caMSRYsqMjSRx2VbLDBivvFi5PrrqvI0gAAAAAAdBACJ6iET30qKRRW3M+bl4wbV5GlN9ww+dznSsdGjEiKxYosDwAAAABAByBwgkrYZJNVD1OqYlu9Z55JHn+8YssDAAAAALCeEzhBpZS31Rs5smLbjPbbL/nAB0rHRoyoyNIAAAAAAHQAAieolKFDS+8nTVq21agCOnVKTjyxdOz66yt2jBQAAAAAAOs5gRNUyoc/vOo2owq21SsPnGbOTG67rWLLAwAAAACwHhM4QaUUCk231auQQYOS/fcvHdNWDwAAAACA1iBwgkoqb6s3YULy5psVW3748NL7MWOSyZMrtjwAAAAAAOspgRNU0r77Jj17rrgvFpPbb6/Y8p/7XFJXt+J+6dLk6qsrtjwAAAAAAOspgRNUUteuySc/WTo2alTFlu/ePTnqqNKxESOW5V4AAAAAALC2BE5QaeVt9caMSRYurNjyJ59cev/yy8kDD1RseQAAAAAA1kMCJ6i0ww5LCoUV93PmJOPGVWz5j3882Wab0rERIyq2PAAAAAAA6yGBE1Tappsmu+9eOlbBtnqFQjJ8eOnYTTclc+dWrAQAAAAAANYzAieohmHDSu9HjqzoQUrHH590WunXP2dOcvPNFVseAAAAAID1jMAJqqE8cGpoSJ59tmLL9+2bHHpo6Zi2egAAAAAArC2BE1TDDjskW25ZOlbBtnrJqm317rsvefXVipYAAAAAAMB6QuAE1VAoNN1Wr4KGDUt69y4du/LKipYAAAAAAMB6QuAE1VIeOD38cDJtWsWW79o1OfbY0rGrrkqWLq1YCQAAAAAArCcETlAt++6b9Oix4r5YTO64o6IllLfVmzgxuffeipYAAAAAAMB6QOAE1dKtW3LIIaVjFW6rN2RI8tGPlo6NGFHREgAAAAAAWA8InKCaytvq3XVXsnBhRUso3+X0hz8kb79d0RIAAAAAAFjHCZygmg47LCkUVtzPmZP8+c8VLeHYY5Pa2hX3CxYkN95Y0RIAAAAAAFjHCZygmjbbLNltt9KxCrfV23jjVTdaaasHAAAAAEBzCJyg2srTnpEjk2KxoiWcfHLp/YQJyfPPV7QEAAAAAADWYQInqLahQ0vvX3ut4mnPJz+ZbLFF6ZhdTgAAAAAAvF/tMnB68803c/nll+fcc8/NTTfdlHnz5lW7JGg7H/lIMmBA6ViF2+rV1CTHH186ds01ybvvVrQMAAAAAADWURUPnF544YV84QtfyFFHHZW33357lee33XZbPvShD+XUU0/NWWedlS9+8YvZbrvt8uSTT1a6VKiMQqHptnoVNnx46f2bbyZ33lnxMgAAAAAAWAdVPHC65ZZbcvPNN+f1119Pr169Sp5NmzYtxx13XObNm5disdj4Z9KkSRk2bFjmzJlT6XKhMsrb6j30UDJ9ekVL2Hbb5OMfLx3TVg8AAAAAgPej4oHTPffck0KhkKHl/8Ce5OKLL86cOXNSU1OTCy64IE899VT++7//O506dcrrr7+e3/zmN5UuFypj//2THj1W3BeLye23V7yM8l1OI0cm//hHxcsAAAAAAGAdU/HAaeLEiUmSIUOGrPLs97//fQqFQk444YR861vfyo477phvf/vbOeWUU1IsFnPbbbdVulyojG7dkoMPLh2rQlu9o45KNthgxf3ixcl111W8DAAAAAAA1jEVD5ymTZuWJNl0001LxqdPn57nnnsuSXLMMceUPDviiCOSJM8//3wFKoQqKd/1d9ddyaJFFS2hvj757GdLx0aMWLbhCgAAAAAAVqfigdP8+fOTJAsWLCgZHz9+fJKkS5cu2WuvvUqebbHFFkmSt99+u+0LhGo5/PDS+9mzkz//ueJllLfVe/rp5IknKl4GAAAAAADrkIoHTr17906yorXecvfcc0+SZJdddkmXLl1Kni1evDhJ0rNnzwpUCFWy+ebJbruVjlWhrd7++ycDB5aOjRhR8TIAAAAAAFiHVDxw+uhHP5okuf766xvH5s+fn9/97ncpFAo54IADVnmnoaEhSbLZZptVpkiolvK2eiNHVryfXadOyYknlo5dd11StikRAAAAAAAaVTxwOvroo1MsFjNy5MgcffTRueiii3LIIYdk2rRpKRQK+eIXv7jKO3/5y1+SJAPLt13A+mbYsNL7v/89eeGFipdx0kml9zNnJrfdVvEyAAAAAABYR1Q8cDrhhBOy1157pVgs5ne/+13OOOOMPPjgg0mS4cOHZ9ttt13lnT/84Q8pFArZc889K10uVNZHP5r07186VoW2eoMGJfvtVzqmrR4AAAAAAKtT8cCpU6dOueOOO/Jv//Zv6d+/f2pqajJgwID84Ac/yCWXXLLK/FGjRuW1115Lkhx22GEVrhYqrFBYta3eqFFVKeXkk0vvx4xJpkypSikAAAAAALRzhWKxwgfENNPMmTMza9asJFrqra3JkydnwIABSZJJkyalf/kOGtqX229PDj98xX2nTsm0aUmfPhUtY968ZPPNk9mzV4z9538m//7vFS0DAAAAAIBW1ha5QcV3ODXXRhttlIEDBwqb6DgOOCDp3n3F/dKlyR13VLyM7t2To44qHRsxImnfETUAAAAAANXQ7gMn6HC6dUsOOqh0rArnOCXJ8OGl9y+9lPzzyDUAAAAAAGhU8cDp3XffzfPPP5/nn38+CxcuXOX5ggULcuaZZ2bAgAHZYIMNsv322+eXv/xlpcuE6ho2rPT+zjuTRYsqXsYeeyTbbFM6NmJExcsAAAAAAKCdq3jg9Mc//jE77rhj9t133yaff+Yzn8n//u//ZsqUKVm4cGH++te/5lvf+lZOP/30ClcKVbTyGU5JMmtWMn58xcsoFJKTTiod++1vk7lzK14KAAAAAADtWMUDp7vuuivFYjFHHnlkunbtWvJs9OjRueuuu5Ik/fv3z2c+85n069cvxWIxl1xySR7Uy4uOYostkl12KR2rUlu9E05IOq30/ynmzEl+//uqlAIAAAAAQDtV8cDp8ccfT6FQaHKH0xVXXJEk2XrrrfPcc8/l97//fZ599tlst912SZLLLrusorVCVZW31Rs5MikWK15G377JJz9ZOqatHgAAAAAAK6t44DRt2rQkyeDBg0vGly5dmnvuuSeFQiHf+MY3UldXlySpr6/P6aefnmKxmIceeqjS5UL1lAdOr7yS/O1vVSll+PDS+3HjkldfrUopAAAAAAC0QxUPnKZPn54k2WCDDUrGn3zyycyaNStJcnjZ+TU77LBDkmTSpEkVqBDaiZ12Svr1Kx2rUlu9I45IevcuHbvqqqqUAgAAAABAO1TxwGn5uU3Lg6fl/vznPydZdnbTwIEDS54t3+20ZMmSClQI7UShkAwdWjpWpcCpa9fkmGNKx666Klm6tCrlAAAAAADQzlQ8cFoeJv3lL38pGR85cmQKhUL22WefVd6ZMWNGkmSTTTZp+wKhPSlvq/fAA8k/fw+VVt5Wr6EhGTu2KqUAAAAAANDOVDxw2n///VMsFvPLX/4yL7zwQpLktttuy7hx45Ikhx122CrvPPvss0mSLbbYomJ1QrtwwAHJyu0nly5N7rijKqUMGZJ85COlY1dcUZVSAAAAAABoZyoeOH3jG99Ily5dMm3atOywww7ZeOON85nPfCbFYjH9+vXL5z73uVXeGTNmTAqFQj5S/q/dsL7bYIPkoINKx6rUVq9QSE4+uXTsD39I3n67KuUAAAAAANCOVDxw2mqrrXLNNdeke/fuKRaLmTFjRorFYnr16pUbbrghXbp0KZn/xhtv5E9/+lOS5IADDqh0uVB95ec43Xln8u67VSnl2GOT2toV9wsWJL/9bVVKAQAAAACgHampxqKf//zns++++2b06NF54403ssUWW+SII45I7969V5n79NNP55hjjknSdLs9WO+VB07vvJOMH5/sv3/FS9l442XHSv3hDyvGRoxIvvKVipcCAAAAAEA7UigWi8VqF0Hbmjx5cgYMGJAkmTRpUvr371/limi2XXZJHntsxf2//mtywQVVKWXUqGWh08qefz7ZbruqlAMAAAAAQDO1RW5Q8ZZ6wFoo3+U0alR16khy6KHJ5puXjo0YUZ1aAAAAAABoH9pF4PTmm2/mnnvuye9+97v87ne/yz333JM333yz2mVB+1G+peill5K//a0qpdTUJMcfXzp2zTXJ4sVVKQcAAAAAgHagaoFTsVjM//3f/2XHHXdM3759c8ghh+Too4/O0UcfnUMOOSR9+/bNjjvumEsvvTS6/tHhfexjSd++pWMjR1anliTDh5fev/FGcued1akFAAAAAIDqq0rgNHPmzOyzzz752te+lueffz7FYrHJP88//3y++tWvZp999snbb79djVKhfSgUksMPLx2rYlu97bZLdt+9dExbPQAAAACAjqum0gsWi8V8+tOfzgMPPJAk6dOnT77whS9k9913z+b/PBjmjTfeyIQJE3LTTTdl+vTpefDBB/PpT3869913X6XLhfZj2LDkN79ZcT9+fDJzZrLRRlUpZ/jw5C9/WXE/cmQyfXqy8cZVKQcAAAAAgCqq+A6n66+/PuPHj0+hUMixxx6bV199Nb/61a9ywgkn5JBDDskhhxySE044IRdddFFeffXVHH/88SkWixk/fnxuuOGGSpcL7ceBBybduq24X7IkueOOqpVz9NGl5bz7bnLddVUrBwAAAACAKqpK4JQk++67b6655prU1dWtdm7Pnj1z1VVXZd99902xWMy1115bqTKh/enefVnotLIqttWrr08++9nSMW31AAAAAAA6pooHTo8//ngKhUJOP/309/3ON77xjSTJE0880VZlwbph2LDS+zvuWLa1qEqGDy+9f+qpxM8UAAAAAKDjqXjgNGPGjCTJoEGD3vc7y+cufxc6rKFDS+/ffjv553lo1XDAAcmWW5aOXXFFdWoBAAAAAKB6Kh441dfXJ0lef/319/3O1KlTkyQbbrhhm9QE64x+/ZIhQ0rHqthWr1On5KSTSseuvz5ZuLAq5QAAAAAAUCUVD5x22GGHJMmIZhz2snzu8nehQytvqzdyZHXq+KfywGnGjOS226pSCgAAAAAAVVLxwOlf/uVfUiwW88c//jFnn312isXiGuf/9Kc/ze9///sUCoV8/vOfr1CV0I6VB04vvrjsT5UMGpTst1/pWDPyZAAAAAAA1gOF4nslPq3s3XffzUc+8pH87W9/S6FQyIc//OGcdNJJ2X333bPpppumUCjkzTffzF/+8pdcddVVefbZZ1MsFrPddtvlqaeeSk1NTSXLXS9Mnjw5AwYMSJJMmjQp/fv3r3JFtMjSpcta673xxoqx889P/u3fqlbS1VcnJ5644r5Tp2TixGVlAgAAAADQvrRFblDxwClJXnvttRx44IH5+9//nkKhsMa5xWIxH/zgB3PPPfdk4MCBFapw/SJwWg99+cvJZZetuN9vv2Ts2KqVM3dussUWyezZK8bOOSf53veqVhIAAAAAAKvRFrlBxVvqJckHPvCBPP300znzzDNTX1+fYrHY5J/6+vp8+9vfzpNPPilsgpWVt9W7//7k7berUkqS9OiRfOELpWMjRiSVj7MBAAAAAKiGquxwWtmiRYvy2GOP5dlnn82MGTOSJL17984OO+yQnXfeOV26dMnkyZPz+OOPJ0mOOOKIVq+hoaEhv/jFLzJ69OhMmjQpXbt2zYc+9KF84QtfyNe//vV079691da6++67c+2112b8+PGZOnVqampqstlmm+UjH/lIDjzwwBx//PHp2bNnq62X2OG0Xpo7N+nTJ1m4cMXYDTckRx9dtZIeeCDZa69Vx/bcszr1AAAAAADQtPWmpV5zXXXVVRk+fHg6deqUxYsXt+pnjxw5Mscdd1xmzZrV5POtt946o0ePzuDBg1u0zsyZMzN8+PDceuuta5z3xBNPZKeddmrRWuUETuupww9Pbr99xf0xxyTXXVe1corFZNttkxdfXDH2pS8lv/lN1UoCAAAAAKAJ601LvbXV2tnYE088kaOOOiqzZs1Kz54987Of/SwPPvhg7rnnnnz5y19Okrz44os5/PDDM3vlw2ma6Z133snBBx/cGDZ95jOfyXXXXZeHH344jzzySP7whz/kjDPOEATRPOVt9W6/vXTHU4UVCslJJ5WO/fa3yzZjAQAAAACwfqupdgHVdMYZZ2T+/PmpqanJmDFjssceezQ+O+CAA7LVVlvlO9/5Tl588cWcf/75Ofvss9dqnW984xt57LHH0rVr19x0002rtAXcZZdd8pnPfCY///nPs2TJkpZ8JTqSww8vvX/77eTmm5Njj61KOUlywgnJf/xHsnTpsvvZs5M//CE5/viqlQQAAAAAQAWsUzucWtOECRNy//33J0lOOeWUkrBpuTPPPDPbbbddkuTCCy/Mu+++2+x1xo8fn2uuuSZJ8v/+3/9b4xlUhUIhNTUdOgOkOQYMSPbfv3TskkuqU8s/9euXHHJI6diIEdWpBQAAAACAyumwgdMtt9zSeD18+PAm53Tq1CknnHBCkuTtt9/O2LFjm73ORRddlCSpr6/P6aef3vxCYU2++tXS+wceSJ55pjq1/FP5z2ns2OTvf69OLQAAAAAAVEaHDZzGjx+fJOnRo0d23nnn1c7bd999G68feOCBZq2xaNGixnObDj744HTr1i1JsmTJkkyaNCmvvfZaFixY0NzSYYUjj0w237x0rMq7nI44Itloo9KxK6+sSikAAAAAAFRIhw2cXnjhhSTJ4MGD19jGbtttt13lnffrqaeeagyUdtxxx8yaNSvf+ta3svHGG2fLLbfMoEGDUl9fn4MPPjjjxo1r/peA2trkS18qHbvmmmWHJ1VJt27JMceUjl111YpznQAAAAAAWP90yMBpwYIFmT59epKkf//+a5y70UYbpUePHkmSSZMmNWud559/vvF66dKl2WWXXXLhhRfm7bffbhxftGhR7r777hxwwAE599xzm/X5y02ePHmNf6ZOnbpWn8s64tRTk04r/ZTnzEmuu6569SQ5+eTS+4aGZa31AAAAAABYP3XIwGn2Srs/evbs+Z7zlwdOc+bMadY6M2bMaLw+99xz89JLL+XQQw/NhAkTsmDBgkybNi2XXHJJ6uvrUywW873vfa+xBV9zDBgwYI1/dtttt2Z/JuuQAQOSoUNLxy65JCkWq1NPkiFDko98pHRsxIjq1AIAAAAAQNtbfS+5VvCTn/ykVT7nySefbJXPWW7lc5O6/P/s3Xd4VFX+x/HPpBESei+hQ+gg3dBRRBFFFFF0bYgg6LrYll1Z21p+rmvZRV1BkbJWcAEpIqggvfeiAURq6B3SSJvfH8cwuZnUyUxuknm/nuc+mTn3zj3fYTWy85nvOSEhuV5fqlQpSVJCQkK+5omLi7PMecMNN+jbb79VYGCgJKlq1aoaNWqUWrVqpV69eiktLU3PPfecBg4cKIfDka+54OdGj5bmzXM937FDWrtW6trVlnIcDmnYMOmpp1xjs2ZJ//mPVL68LSUBAAAAAAAAAHzIp4HTyy+/XCSDk9DQ0KuPk5KScr3+ypUrkqTSpUt7PI9kupzSw6aMunfvrjvuuEMzZ85UdHS0du7cqTaZ20NykNtSf8ePH6fLqaTr109q2FDav981NmGCbYGTJP3hD9Kf/yylpJjniYnSjBlmBUAAAAAAAAAAQMni8yX1nE6nVw5vKlu27NXHeVkmL71TKS/L72U3T9WqVdWuXbtsr73xxhuvPt64cWO+5omIiMjxqFmzZr7uh2IoIEB69FHr2NdfS7/vVWaHqlWlW2+1jrGsHgAAAAAAAACUTD7tcFq6dKkvb++x0NBQVa5cWWfPnlVMTEyO154/f/5q4FSnTp18zZPx+oiIiDxfe/r06XzNA0gya9i98IKU3rWXlGQSnj//2daSvvnG9XzdOik6Wmre3LaSAAAAAAAAAAA+4NPAqVevXr68fYG0aNFCK1eu1L59+5SSkqKgoKz/KHbv3n31cfN8fkresmXLq49TU1NzvDbj+exqAXJUtao0ZIj0xReusY8+kp55xnRA2aB/f6l6denkSdfYtGnSm2/aUg4AAAAAAAAAwEfs+RS6COjevbsks1ze5s2bs71u+fLlVx9369YtX3PUq1dPdevWlSQdPHgwx6UBf/vtt6uPa9euna95gKtGj7Y+/+036ccf7alFUlCQdP/91rFPP3Xt6wQAAAAAAAAAKBn8NnAaNGjQ1cdTs9lYJi0tTZ9++qkkqUKFCurTp0++5xk8eLAk6dKlS1qyZEm2182ePfvq4/QwDMi3rl2l1q2tYxMm2FPL74YNsz4/cUL6/nt7agEAAAAAAAAA+IbfBk6dO3dWjx49JEmTJ0/W2rVr3a555513FB0dLUkaM2aMgoODLeeXLVsmh8Mhh8Ohhx56KMt5nnzySYWGhkqSnn76aV26dMntms8//1zLli2TJA0YMCDfe0UBVzkc7l1O8+dLR47YU4+kFi2kzp2tY9lkvAAAAAAAAACAYspvAydJGj9+vEqXLq2UlBT169dPb7zxhtatW6elS5fq0Ucf1dixYyVJkZGReuaZZzyao27dunrllVckSTt37lTnzp01depUbd68WUuXLtUTTzxxNawqV66c/vWvf3nlvcGP3XefVKaM63lamjRpkn31yL3Lad486cwZe2oBAAAAAAAAAHhfkN0F2Kldu3aaMWOG7rvvPl26dEnjxo1zuyYyMlILFixQ2bJlPZ7nz3/+s86dO6c333xTe/bs0cMPP+x2TbVq1TRnzhw1adLE43kASVLZsiZ0mjjRNfbJJ9ILL0iZuvQKy9Ch0lNPSYmJ5nlysvTFF9KYMbaUAwAAAAAAAADwMr/ucJKkW2+9VTt27NBTTz2lyMhIhYWFqUKFCurYsaPefPNNbd26VY0bNy7wPG+88YZWr16t+++/X/Xr11epUqVUvnx5derUSa+++qr27t2rqKgoL7wjQO7L6h0/Ls2da08tkipUkG6/3TrGsnoAAAAAAAAAUHI4nE6n0+4i4FsxMTFX94U6cuSIIiIibK4IhaJbN2nNGtfz666TliyxrZzFi6UbbrCObdkitWtnTz0AAAAAAAAA4K98kRv4fYcTUGJl7nL66Sdpzx57apHJu+rWtY7R5QQAAAAAAAAAJQOBE1BS3XmnVLmydSzjvk6FLCBAevBB69gXX0hXrthTDwAAAAAAAADAewicgJIqNFR6+GHr2LRpUny8LeVI0kMPWZ+fOyfNn29LKQAAAAAAAAAALyJwAkqyRx+1Pr9wQZoxw5ZSJKlhQ6lXL+sYy+oBAAAAAAAAQPFH4ASUZI0aSTfeaB2bMMGeWn43bJj1+aJF0rFj9tQCAAAAAAAAAPAOAiegpBs92vp840Zp82Z7apHZWqpMGdfztDTps89sKwcAAAAAAAAA4AUETkBJN2CAFBFhHbOxyyk8XLrrLuvY1KmS02lPPQAAAAAAAACAgiNwAkq6oCBp5Ejr2Jdfmv2cbJJ5Wb09e6R16+ypBQAAAAAAAABQcAROgD945BETPKVLSJA+/dS2crp1k5o0sY5NnWpPLQAAAAAAAACAgiNwAvxBzZrSoEHWsYkTbVvHzuGQHnrIOjZ9uhQfb0s5AAAAAAAAAIACInAC/MXo0dbn0dHS8uX21CLpgQekgAy/gS5flmbMsK0cAAAAAAAAAEABEDgB/qJPH6lpU+vYhAn21CIpIkK64Qbr2Lhx0vnz9tQDAAAAAAAAAPAcgRPgLxwOadQo69js2dKJE/bUI/emqxMnpKeftqcWAAAAAAAAAIDnCJwAf/Lgg1Lp0q7nKSnS5Mm2lTNwoHTzzdaxadOk77+3pRwAAAAAAAAAgIcInAB/UrGiNHSodezjj6XUVFvKcTikiROlsmWt4yNHmj2dAAAAAAAAAADFA4ET4G8yr2N3+LD03Xf21CKpTh3p7betY4cPS3/9qz31AAAAAAAAAADyj8AJ8DedOkkdOljHJkywp5bfjRgh9eljHfvwQ2n5cnvqAQAAAAAAAADkD4ET4I8ydzktWiQdOGBPLTJL602aJIWFWccfeUSKj7enJgAAAAAAAABA3hE4Af5o6FCpfHnXc6dT+ugj++qR1KiR9Prr1rF9+6QXX7SnHgAAAAAAAABA3hE4Af4oPFx68EHr2OTJ0pUr9tTzuyeekKKirGP/+pe0fr099QAAAAAAAAAA8obACfBXo0ZZn585I82aZU8tvwsMNLlXSIhrLC1Nevhh27MwAAAAAAAAAEAOCJwAf9W8udS7t3VswgRbSsmoeXPp5ZetY7/84r7cHgAAAAAAAACg6CBwAvzZ6NHW56tWSTt32lNLBs8+K7VrZx174w1p+3Z76gEAAAAAAAAA5IzACfBngwZJ1atbxyZOtKWUjIKDpSlTpKAg11hKijRsmJScbF9dAAAAAAAAAICsETgB/iwkRHrkEevYZ59JsbH21JPBNddIf/2rdWzrVuntt20pBwAAAAAAAACQAwInwN+NHCkFZPhVcPmy9MUX9tWTwfPPSy1aWMf+/ncpOtqeegAAAAAAAAAAWSNwAvxd3brSgAHWsQkTJKfTnnoyKFXKLK2XMQ+7ckUaPlxKTbWvLgAAAAAAAACAFYETAGn0aOvz7duldevsqSWTLl2kp56yjq1dK33wgT31AAAAAAAAAADcETgBkG68UWrQwDo2YYI9tWThlVekxo2tY+PGSfv321MPAAAAAAAAAMCKwAmAWbPu0UetY19/LZ09a089mYSFSZ98Yh2Lj5ceeaRIrPwHAAAAAAAAAH6PwAmA8fDDUkiI6/mVK9LUqfbVk0mvXu4r/y1dKk2aZE89AAAAAAAAAAAXAicARtWq0p13WscmTpTS0uypJwtvvinVrWsde/ZZ6cgRe+oBAAAAAAAAABgETgBcMrcQ/fabtHixPbVkoWxZ6eOPrWOXL0ujRrG0HgAAAAAAAADYicAJgEu3blKrVtaxCRPsqSUbN94oPfSQdey776QvvrClHAAAAAAAAACACJwAZORwuHc5zZsnxcTYU0823n1XqlHDOjZmjHTypD31AAAAAAAAAIC/I3ACYHXffVJ4uOt5Wpo0aZJ99WShYkX3xqtz56Q//tGeegAAAAAAAADA3xE4AbAqV86EThlNmiQlJ9tTTzYGDZLuvts6NnOmNGuWLeUAAAAAAAAAgF8jcALgLvOyesePm6X1ipj335cqV7aOPf64dPasPfUAAAAAAAAAgL8icALgrm1bKSrKOpZ5DbsioGpVEzpldPKk9NRT9tQDAAAAAAAAAP6KwAlA1jJ3OS1ZIu3da08tORg6VLr1VuvYZ59J331nTz0AAAAAAAAA4I8InABkbcgQ9/XqJk60p5YcOBym+ap8eev4o49Kly7ZUxMAAAAAAAAA+BsCJwBZCw2Vhg2zjk2bJiUk2FJOTmrXlt55xzoWEyONHWtPPQAAAAAAAADgbwicAGTv0Uetz8+fl2bMsKeWXDz8sNS3r3Xso4+kpUvtqQcAAAAAAAAA/AmBE4DsNW4s9etnHZswwZ5acuFwSJMmSeHh1vFHHpHi4uypCQAAAAAAAAD8BYETgJyNHm19vmGDtGWLPbXkon596R//sI7t3y89/7wt5QAAAAAAAACA3yBwApCzW26RIiKsY0W0y0mSHntM6t7dOjZ+vLR2rT31AAAAAAAAAIA/IHACkLOgIGnECOvYl19KFy/aU08uAgKkyZOl0FDXmNNp9nhKTLSvLgAAAAAAAAAoyQicAOTukUekwEDX8/h46dNP7asnF5GR0t//bh3bvVt69VV76gEAAAAAAACAko7ACUDuatWSBg2yjk2YYFqHiqinn5Y6drSOvflmkd1+CgAAAAAAAACKNQInAHkzerT1eXS0tGKFPbXkQVCQNGWKFBzsGktNNUvrJSfbVxcAAAAAAAAAlEQETgDy5rrrzFp1GU2YYE8tedS6tfS3v1nHtm83nU4AAAAAAAAAAO8hcAKQNw6HNGqUdWz2bOnkSXvqyaPnnjPBU0avvir9/LM99QAAAAAAAABASUTgBCDvHnxQCg11PU9OliZPtq+ePAgJMUvrBWT4bZeUJA0fbpbYAwAAAAAAAAAUHIETgLyrVEkaOtQ69tFHRT656dhRevZZ69j69dL48fbUAwAAAAAAAAAlDYETgPwZPdr6/PBhaeFCe2rJh5dfdt+C6m9/k/bts6UcAAAAAAAAAChRCJwA5E+nTlL79taxCRPsqSUfSpc2q/85HK6xxETpkUektDT76gIAAAAAAACAkoDACUD+OBzuXU4LF0oHDthTTz507y798Y/WseXLzaqAAAAAAAAAAADPETgByL977pHKl3c9dzqljz+2r558+L//k+rXt46NHWtWBgQAAAAAAAAAeIbACUD+hYdLDzxgHZs8WbpyxZ568qFMGWnSJOtYbKw0cqTJzQAAAAAAAAAA+UfgBMAzo0ZZn58+Lc2aZU8t+dS3rzR8uHXs+++lTz+1px4AAAAAAAAAKO4InAB4pkULqVcv69iECfbU4oG335Zq1bKOPfmkdPy4LeUAAAAAAAAAQLFG4ATAc489Zn2+apW0c6c9teRThQrSxInWsQsXzFtiaT0AAAAAAAAAyB8CJwCeGzRIql7dOpY5xSnCbr1Vuvde69icOdL//mdLOQAAAAAAAABQbBE4AfBcSIj0yCPWsc8+k2Jj7anHA+PHS1WrWsf++EfpzBl76gEAAAAAAACA4ojACUDBjBwpBWT4VXL5svTFF/bVk09VqkgffGAdO31aGjPGnnoAAAAAAAAAoDgicAJQMHXrSgMGWMcmTChWGyENGWJWB8zoyy+l+fNtKQcAAAAAAAAAih0CJwAFN3q09fn27dK6dfbU4gGHQ/rwQ6lCBev4qFHShQt2VAQAAAAAAAAAxQuBE4CCu/FGqUED69iECfbU4qGaNaV//cs6duyY9Oc/21MPAAAAAAAAABQnBE4ACi4gQHr0UevY119LZ8/aU4+HHnzQZGcZffKJtHixPfUAAAAAAAAAQHFB4ATAOx5+WAoJcT2/ckWaOtW+ejzgcEgffyyVKWMdHzFCio21pyYAAAAAAAAAKA4InAB4R9Wq0p13WscmTpTS0uypx0N160r//Kd17OBBadw4W8oBAAAAAAAAgGKBwAmA94webX3+22/Fcj26Rx+Veva0jn3wgbRqlT31AAAAAAAAAEBRR+AEwHu6dZNatbKOTZhgTy0FEBAgTZ4slS7tGnM6peHDpYQE++oCAAAAAAAAgKKKwAmA9zgc7l1O8+ZJMTH21FMAjRtLr75qHdu7V/r73+2pBwAAAAAAAACKMgInAN51331SeLjreVqaNGmSffUUwJNPSp07W8feekvatMmWcgAAAAAAAACgyCJwAuBd5cqZ0CmjSZOk5GR76imAwEBpyhQpONg1lpYmPfywlJRkX10AAAAAAAAAUNQQOAHwvszL6h0/bpbWK4ZatpRefNE6tnOn9MYb9tQDAAAAAAAAAEURgRMA72vbVoqKso5NmGBPLV7wl7+Yt5TR66+b4AkAAAAAAAAAQOAEwFcydzktWSLt3WtPLQUUHGyW1gsMdI0lJ5ul9VJS7KsLAAAAAAAAAIoKAicAvjFkiFS5snVs4kR7avGC9u2lsWOtY5s2Sf/6lz31AAAAAAAAAEBRQuAEwDdCQ6Vhw6xj06ZJCQm2lOMNL74oNWvmPlZMG7cAAAAAAAAAwGsInAD4zqOPWp+fPy/NmGFPLV4QGmqW1nM4XGOJidLw4VJamn11AQAAAAAAAIDdCJwA+E7jxlK/ftaxCRPsqcVLoqKkMWOsY6tWSR9+aE89AAAAAAAAAFAUEDgB8K3Ro63PN2yQtmyxpxYvee01qWFD69hf/yodPGhLOQAAAAAAAABgOwInAL51yy1SRIR1rJh3OYWHS5MmWcfi4qRHHpFSU+2pCQAAAAAAAADsROAEwLeCgqQRI6xjX34pXbxoTz1ect110siR1rElS6Tnn7enHgAAAAAAAACwE4ETAN975BEpMND1PD5e+vRT++rxkn/+07156x//MHkaAAAAAAAAAPgTAicAvlerljRokHVswgTJ6bSlHG8pX176/HPTxJXR8OHSxo321AQAAAAAAAAAdiBwAlA4Ro+2Po+OllassKcWL+rVS3r/fetYYqLJ144ds6UkAAAAAAAAACh0BE4ACsd110mRkdaxCRPsqcXLRo2SHnvMOnbsmHT77VJCgj01AQAAAAAAAEBhInACUDgcDpPMZDR7tnTypD31eNm//y316WMd27BBGjmy2K8cCAAAAAAAAAC5InACUHgefFAKDXU9T06WJk+2rx4vCg6W/vc/qUED6/jnn0tvvWVPTQAAAAAAAABQWAicABSeSpWkoUOtYx99JKWm2lOPl1WuLM2fL5UpYx3/61+lBQvsqQkAAAAAAAAACgOBE4DCNXq09fnhw9LChfbU4gMtW0pffmlWEEzndEr33CP98ot9dQEAAAAAAACALxE4AShcnTpJ7dtbxyZMsKcWH7n1Vun1161jly9LAwdKZ8/aUxMAAAAAAAAA+BKBE4DC5XC4dzktXCgdOGBPPT7y179K995rHfvtN+muu8zWVQAAAAAAAABQkhA4ASh899wjlS/veu50Sh9/bF89PuBwSJ98InXsaB3/6Sfp6aftqQkAAAAAAAAAfIXACUDhCw+XHnjAOjZ5snTlij31+Ejp0tKcOVLNmtbxDz4ocfkaAAAAAAAAAD9H4ATAHqNGWZ+fPi29+649tfhQ7drSN99IpUpZxx9/XFqxwp6aAAAAAAAAAMDbCJwA2KNFC6lXL+vYuHHSX/4ipaXZU5OPdOliltfLKCVFGjxYOnjQlpIAAAAAAAAAwKsInADY589/dh/75z/NcntJSYVfjw/dd580dqx17MwZ6bbbpNhYe2oCAAAAAAAAAG8hcAJgnwEDpNdecx//4gvp5pulS5cKvyYf+r//M285ox07TL5Wwpq6AAAAAAAAAPgZAicA9vrb36QpU6TAQOv4kiVSz57SsWP21OUDgYHSl19KzZtbx7/5Rnr5ZVtKAgAAAAAAAACvIHACYL9hw6T586XwcOv49u1SVJQUHW1PXT5Qrpw0b55UsaJ1/NVXpa+/tqcmAAAAAAAAACgoAicARUP//tKyZVK1atbxw4elbt2k1attKcsXGjeW/vc/96auhx6StmyxpSQAAAAAAAAAKBACJwBFR8eO0po1JpHJ6Px5qW9fs/ZcCXH99dK//20dS0iQbrtNOnHClpIAAAAAAAAAwGMETgCKlkaNTOjUubN1PDFRGjxY+uADe+rygccfl0aMsI7FxEh33CFduWJPTQAAAAAAAADgCQInAEVP1arSTz9Jt9xiHXc6pSeekJ57zjwu5hwOk5/16GEdX7tWGjWqRLxFAAAAAAAAAH6CwAlA0RQebpbQy9wCJEn/+If04INSUlLh1+VlISHSrFlSvXrW8WnT3JfcAwAAAAAAAICiisAJQNEVFCR99JH097+7n/vsM2nAAOnSpcKvy8uqVpXmzTMZW0bPPit9/709NQEAAAAAAABAfhA4ASjaHA7pxRelTz6RAgOt5xYvlnr1ko4ft6c2L2rTxmRoGaWlSXffLe3ZY09NAAAAAAAAAJBXBE4Aiofhw00bUFiYdXzbNikqStq925ayvOn226VXXrGOXbwoDRwonT9vT00AAAAAAAAAkBcETgCKj5tvlpYtM2vQZXTokNStm7RmjS1ledPzz0tDhljH9u6Vhg6VUlLsqQkAAAAAAAAAckPgBKB46dRJWrtWatTIOn7unHT99dKcObaU5S0OhzRtmtSunXX8hx+ksWNtKQkAAAAAAAAAckXgBKD4adTIdDN16mQdT0yUBg+WPvzQnrq8JCxMmjtXqlbNOv6vf0lTpthTEwAAAAAAAADkhMAJQPFUrZq0dKlZZi+jtDTp8celceMkp9Oe2rygTh3pm2+kkBDr+KhR0urV9tQEAAAAAAAAANkhcJJ06NAhPfPMM2rWrJnCw8NVqVIlderUSW+99Zbi4+MLdO9p06bJ4XDk6Zg2bZp33hDgL8LDTSvQI4+4n3vjDemhh6Tk5EIvy1u6dpUmTrSOJSdLd9whHT5sT00AAAAAAAAAkBW/D5zmz5+vNm3a6N1339WePXsUHx+v8+fPa9OmTRo7dqzatWunffv22V0mgOwEBUkffyy9/LL7uU8/lW65Rbp8udDL8pZhw6SnnrKOnTol3XabFBdnT00AAAAAAAAAkFmQ3QXYaevWrbr77ruVkJCgMmXK6LnnnlOfPn2UkJCg6dOna9KkSdq7d68GDBigTZs2qWzZsgWa7/vvv1etWrWyPR8REVGg+wN+y+GQXnpJql3brDmXmuo698MPUq9e0nffSTVq2FdjAfzzn9Ivv0jff+8a27bNhFEzZpi3DwAAAAAAAAB28uvAacyYMUpISFBQUJB++OEHRUVFXT133XXXqUmTJho7dqz27t2rd955Ry9n1UGRD5GRkapfv37BigaQvUcekWrWlO66S8q4HObWrVJUlLRokdS0qX31eSgoSJo+XerSRdq71zX+v/9JrVtLL7xgX20AAAAAAAAAIPnxknobNmzQypUrJUnDhw+3hE3pnnnmGTVv3lySNH78eCUX471gAL8xYIC0dKlUpYp1/OBBsynS2rW2lFVQFSpI8+ZJ5ctbx198UZo925aSAAAAAAAAAOAqvw2c5syZc/XxsGHDsrwmICBADzzwgCTpwoULWrp0aWGUBqCgOnc2wVKjRtbxc+ek666T5s61p64CatrULKEXkOk39/33S9u321MTAAAAAAAAAEh+HDitWrVKkhQeHq4OHTpke12vXr2uPl69erXP6wLgJY0bS2vWSB07WscTE6U77pAmTrSnrgK68Ubp7betY/Hx0sCB0qlT9tQEAAAAAAAAAH4bOEVHR0uSGjdurKCg7LeyatasmdtrPDVs2DDVqlVLISEhqlKliq699lo9//zzOnr0aIHuCyAb1aqZ5fX697eOp6VJo0dLzz8vOZ321FYATz4pZW7MPHxYuvNOKSnJlpIAAAAAAAAA+Dm/DJwSExN15swZSVJERESO11asWFHh4eGSpCNHjhRo3mXLlun48eNKTk7W2bNntX79er3++utq3LixPvroI4/vGxMTk+Nx/PjxAtUNFGtlypgl9B5+2P3c66+b5KaY7c/mcEgTJpgtqTJauVJ6/PFimaEBAAAAAAAAKOayb+0pwS5fvnz1cZkyZXK9Pjw8XHFxcYqNjfVovoYNG+qOO+5QVFSU6tSpI0nav3+/Zs2apZkzZyoxMVGjRo2Sw+HQyJEj833/9HsCyEZwsPTJJ1JEhPTKK9Zz//2vdOKE9L//SWXL2lOfB0qVkmbPNisGxsS4xj/5RGrTRnriCftqAwAAAAAAAOB/HE6n/30X/siRI6pbt64k6f7779enn36a4/V169bVkSNH1KhRI+3bty9fc128eFHlypWTw+HI8vy3336rO+64Q8nJyQoLC9Nvv/2mGjVq5GuO7O6dlSNHjuTa1QWUaJMmSaNGmWX1MmrfXlqwQMrnv39227pV6tZNSkhwjQUGSosWSX372lcXAAAAAAAAgKIrJibmajOLt3IDv1xSLzQ09OrjpDxseHLlyhVJUunSpfM9V/ny5XMMhG655Ra9+OKLkqT4+HhNnjw533McOXIkx2PDhg35vidQYo0YYZbYy/zv85YtZo26vXvtqctD7dqZJq2MUlOlu+6Sfv3VnpoAAAAAAAAA+B+/DJzKZlg2Ky/L5MXFxUnK2/J7nhg5cuTVUGr58uX5fn1ERESOR82aNb1dMlC83XKLtHSpVKWKdfzAARM6rVtnT10eGjJE+j23vur8eem226SLF+2pCQAAAAAAAIB/8cvAKTQ0VJUrV5Zk2sZycv78+auBk6/2SqpWrdrVeo4ePeqTOQBk0qWLtGaN1LChdfzsWem666R58+ypy0MvvSTdfrt1LDpauvde0/EEAAAAAAAAAL7kl4GTJLVo0UKStG/fPqWkpGR73e7du68+bt68uc/qyc8+TAC8pEkTEzp16GAdT0gw6c1HH9lTlwcCAqRPP5XatLGOf/ed9Nxz9tQEAAAAAAAAwH/4beDUvXt3SWa5vM2bN2d7XcYl7rp16+aTWk6fPq0zZ85IkmrVquWTOQBko3p1adkyqX9/63hamjRqlFmrzum0pbT8KlPGbE+VeaXAt96SPvvMnpoAAAAAAAAA+Ae/DZwGDRp09fHUqVOzvCYtLU2ffvqpJKlChQrq06ePT2r5+OOP5fz9A+1evXr5ZA4AOUhPaoYNcz/36qvS8OFScnLh1+WB+vWl2bOloCDr+IgR0vr1tpQEAAAAAAAAwA/4beDUuXNn9ejRQ5I0efJkrV271u2ad955R9HR0ZKkMWPGKDg42HJ+2bJlcjgccjgceuihh9xef/DgQW3dujXHOr799lu98sorkqTSpUtrWFYfeAPwveBgafJk6YUX3M9NnSoNHCjFxhZ+XR7o0UP68EPr2JUr0qBBEtvEAQAAAAAAAPCFoNwvKbnGjx+vbt26KSEhQf369dO4cePUp08fJSQkaPr06fr4448lSZGRkXrmmWfyff+DBw+qT58+ioqK0q233qq2bduqWrVqkqT9+/dr5syZmjlz5tXuprffflu1a9f23hsEkD8Oh/TKK1Lt2tJjj5ll9dItWiT17i0tWGCW4SviRoyQdu6U3n/fNXbihAmdVqyQSpe2rTQAAAAAAAAAJZBfB07t2rXTjBkzdN999+nSpUsaN26c2zWRkZFasGCBypYt6/E8a9euzbKDKl1YWJj+9a9/aeTIkR7PAcCLHn1UqllTGjpUSkhwjW/eLHXtasKnJk3sqy+P3n1Xio6WFi92jW3aZFYI/OILk68BAAAAAAAAgDf47ZJ66W699Vbt2LFDTz31lCIjIxUWFqYKFSqoY8eOevPNN7V161Y1btzYo3t36NBBn3/+uR5//HF16dJFdevWVVhYmEJCQlS9enVdd911ev3113XgwAHCJqCoGThQ+uknqXJl6/j+/SZ0KgYbIgUFSTNmSJl/hX31lfSPf9hTEwAAAAAAAICSyeFMX88NJVZMTIzq1KkjSTpy5IgiIiJsrggoRvbulW66STpwwDpeurT09dfSLbfYU1c+REdLXbpIly+7xhwOac4ck6sBAAAAAAAA8C++yA38vsMJAHIUGSmtWSO1b28dT0iQbrtN+n2vt6KseXNp+nTrEnpOp/SHP0i7dtlXFwAAAAAAAICSg8AJAHJTo4a0bJl0443W8bQ0s9/TSy+ZBKcIu/lm6c03rWOxsabD6cwZe2oCAAAAAAAAUHIQOAFAXpQtK82fLz34oPu5V16RHnlESk4u/Lry4dlnpfvvt44dOCANGVLkSwcAAAAAAABQxBE4AUBeBQdLU6dKzz/vfm7KFKlZM9PttG9f4deWBw6HWQGwSxfr+LJl0pgxtpQEAAAAAAAAoIQgcAKA/HA4pFdflSZMkAIy/Qrdv990OzVpIkVFSR9+KJ09a0+d2QgNlb75RqpVyzo+YYI5AAAAAAAAAMATBE4A4IlRo6TZs02Ck5V166THH5dq1pQGDZJmzpQSEwu1xOzUrCnNnete+p/+ZMoEAAAAAAAAgPwicAIAT912m1mPrlWr7K9JTjbpzpAhJukZOVJauVJKSyu0MrPSsaNZBTCjlBRT5pNPSklJtpQFAAAAAAAAoJgicAKAgujSRdqxQ9qwQXriCalKleyvvXBBmjRJ6tlTatRIeuEFac+eQis1s3vukZ57zn18/HipRw/p0KHCrwkAAAAAAABA8UTgBAAF5XBInTpJ770nHTsmzZ8v3XWXVKpU9q85eFB67TWpWTOpc2fp/fel06cLreR0r70mDRvmPr5hg9SunXkrAAAAAAAAAJAbAicA8KbgYOmWW6QZM6STJ6VPPpF69875NRs3mg2UatWSbr1V+vprKSGhUMoNCJAmT5Y++sg9Hzt/Xho4UBo71qwMCAAAAAAAAADZIXACAF8pX14aPlxautSsT/d//yc1b5799Skp0rffSnffLdWoYV67bJnP93tyOMzWUuvWSY0bu59/6y2TmcXE+LQMAAAAAAAAAMUYgRMAFIa6dc2GST//LG3aJI0ZI1Wrlv31ly5JU6ZIffpIDRpI48ZJv/zi0xKvuUbavFkaMsT93Jo15vzChT4tAQAAAAAAAEAxReAEAIXJ4ZA6dJD+/W/p6FHpu++ke+6RSpfO/jWHD0tvvCG1bOl67cmTPimvXDmzGuAHH0ghIdZzZ89KN99ssq+UFJ9MDwAAAAAAAKCYInACALsEBUn9+0tffimdOCFNnSpdf70JpbKzZYv01FNS7dom/fnqKyk+3qtlORzS44+brqYGDdzPv/GGKfPYMa9OCwAAAAAAAKAYI3ACgKKgXDnpoYekxYtNR9Obb0qtWmV/fWqqWd/u3nul6tXNa5csMeNe0qGDybduv9393IoVZom9xYu9Nh0AAAAAAACAYozACQCKmogIaexYaccOaetW6emnpRo1sr8+Nlb673+lvn2levWkv/xF2rXLK6VUqCDNmiX961+mISuj06elfv2kl1/2as4FAAAAAAAAoBgicAKAosrhMG1E77wjxcRI338v3XefFBaW/WuOHpX++U+pdWupXTvp3Xel48cLXMaTT0qrVkl161rPOZ3S3/9ugqcTJwo0DQAAAAAAAIBijMAJAIqDwECT6nz2mXTypPTpp9INN0gBOfwa37ZNeuYZ0zF1443S559LcXEel9Cli2m4uuUW93M//WTyraVLPb49AAAAAAAAgGKMwAkAipsyZaT775d++EE6ckR66y2pbdvsr09LM9fef7/Z7+mBB6Qff/RoHbxKlaS5c00TVWCg9dyJE2ZVv9deM1MCAAAAAAAA8B8ETgBQnNWqJT37rOlm2rFD+vOfzVh24uJMl1S/flKdOua127fna8qAADPN8uVS7drWc2lp0gsvSP37mz2eAAAAAAAAAPgHAicAKClatzatR4cPmw6mBx6QwsOzv/74cbM/1DXXSG3aSB98ICUn53m6bt1MznXTTe7nfvjBLLG3alW+3wUAAAAAAACAYojACQBKmsBAs7bdf/9r9nv64guTCuW039POndITT0gDB0qxsXmeqkoVacEC6f/+z/32R49KvXtLb77JEnsAAAAAAABASUfgBAAlWXi4dO+90sKFJgF6913TepSdRYukPn2kU6fyPEVAgPTcc9JPP0k1a1rPpaZKf/2rybHOnvXwPQAAAAAAAAAo8gicAMBf1KghPfWUtGWLtGuXSYLq1HG/btMms17eb7/l6/a9eklbt5rmqswWLDA519q1HtYOAAAAAAAAoEgjcAIAf9SypfTGG9LBg9J330mVK1vP79snde0qbd6cr9tWr26apF5+WXI4rOeOHJF69jRNVk5ngaoHAAAAAAAAUMQQOAGAPwsIkPr3l1avlurXt547dcpswvTDD/m6ZWCg9NJL0o8/StWqWc+lpEjPPCPdfrt0/nyBKgcAAAAAAABQhBA4AQCkpk2lNWuktm2t47Gx0oAB0uef5/uW118vbdtmMqvM5s6V2reXNm70qFoAAAAAAAAARQyBEwDAqFlTWrHCJEUZpaRI998vvfVWvtfCq1nTdDo9/7z7EnsHD5qtot5/nyX2AAAAAAAAgOKOwAkA4FKunNnT6Z573M+NHSs99ZSUlpavWwYFSa++Ki1cKFWpYj2XnCz96U/SXXdJFy8WoG4AAAAAAAAAtiJwAgBYhYSYJfSeftr93PjxJoy6ciXft73xRmnrVql7d/dzM2dKHTpIW7Z4UC8AAAAAAAAA2xE4AQDcBQRI77wjvf22+7mvv5b69/eoJSkiQvrpJ9Msldlvv0lRUdLEiSyxBwAAAAAAABQ3BE4AgOw984zpdgoOto4vXSr17CkdO5bvWwYHS2++Kc2fL1WsaD2XlCSNHi3de690+XIB6gYAAAAAAABQqAicAAA5+8MfzL5OZcpYx3fskLp2lXbv9ui2t9wibdsmXXut+7np06WOHc0UAAAAAAAAAIo+AicAQO769pWWL5eqV7eOHzokdesmrV3r0W3r1jW3zWq7qL17pS5dpMmTWWIPAAAAAAAAKOoInAAAedO+vbRmjdSkiXX83Dnp+uvNGnkeCAkx20V9841Uvrz1XGKi9Mgj0oMPSnFxHtYNAAAAAAAAwOcInAAAedewobR6tdSpk3U8IUEaNEj65BOPbz1okLR1q1lKL7PPPjNT/vyzx7cHAAAAAAAA4EMETgCA/KlaVVq6VOrf3zqeliaNGCG98orHa+A1aCCtWiU98YT7uehoqXNn6b//9ejWAAAAAAAAAHyIwAkAkH/h4dLcudJDD7mfe+klafRoKTXVo1uXKiW995709ddS2bLWc/HxZsrhw81jAAAAAAAAAEUDgRMAwDPBwdKUKdLf/uZ+7qOPpMGDzVJ7HhoyRNqyRbrmGvdzU6ZIXbpIe/Z4fHsAAAAAAAAAXkTgBADwnMMhvfaa9J//mMcZzZ0r9e0rnTvn8e0bN5bWrpVGjXI/t2uX1KGD9OWXHt8eAAAAAAAAgJcQOAEACu6xx6T//c+sh5fRmjVS9+7S4cMe3zo0VJowwQRLZcpYz8XFSX/4gwmkEhM9ngIAAAAAAABAARE4AQC8Y/Bg6ccfpQoVrOPR0VJUlLRzZ4Fuf8890qZNUuvW7uc++shM8euvBZoCAAAAAAAAgIcInAAA3tOjh7RypVS7tnX82DFzbvnyAt2+aVNp3Tpp+HD3c9u2mf2e3ntPSk0t0DQAAAAAAAAA8onACQDgXa1amY2XWrSwjl+8KPXrZ5beK4CwMOmTT6T//tc8zig+XhozRurZ0zRWAQAAAAAAACgcBE4AAO+rU8d0OnXvbh1PSpLuvlt6//0CT/HAA9LGjVLz5u7n1qwx3U6vvy4lJxd4KgAAAAAAAAC5IHACAPhGpUrSDz9It99uHXc6pT/9SXruOfO4AFq0MKHTqFHu55KSpOeflzp3lrZuLdA0AAAAAAAAAHJB4AQA8J3Spc0SeqNHu5/7xz+khx4qcAtSeLg0YYK0dKnUqJH7+W3bpE6dTL6VmFigqQAAAAAAAABkg8AJAOBbgYHSf/4jvfaa+7lPP5UGDpRiYws8Te/e0o4d0rPPSgGZ/uuWmmryrbZtpVWrCjwVAAAAAAAAgEwInAAAvudwSH/7m/TJJyaAymjRIqlPH+nUqQJPExYmvfWWtHat1KqV+/m9e6WePaUnnvBKxgUAAAAAAADgdwROAIDCM3y4NHeuWWovo02bpG7dpN9+88o0nTtLmzdLL78sBQdbzzmd0gcfmEDqhx+8Mh0AAAAAAADg9wicAACFa8AA6aefpMqVreP79kldu5qkyAtCQqSXXpK2bDF7OGV26JB0443SsGHS+fNemRIAAAAAAADwWwROAIDCd+210urVUv361vFTp8xmTF5sPWrVyiyx9/bb7o1VkjRtmtSihTR7ttemBAAAAAAAAPwOgRMAwB5Nm0pr1kjXXGMdj401XVCff+61qQIDpWeekXbsMHlWZidOSIMHS0OGmMcAAAAAAAAA8ofACQBgn5o1peXLpeuvt46npEj33y+99ZbZdMlLGjeWliyRJk6UypZ1Pz9zpul2+vRTr04LAAAAAAAAlHgETgAAe5UrJ333nXTPPe7nxo6VnnpKSkvz2nQBAdKjj0q//GIaqTI7f1568EHp5pulw4e9Ni0AAAAAAABQohE4AQDsFxJiltB7+mn3c+PHmzDqyhWvThkRIc2fL33xhVS5svv5RYukli2lDz/0at4FAAAAAAAAlEgETgCAoiEgQHrnHentt93Pff211L+/dPGiV6d0OKR77zXdTnff7X4+NlZ6/HGz79PevV6dGgAAAAAAAChRCJwAAEXLM8+YbqfgYOv40qVSz57SsWNen7JaNWn6dGnOHLOtVGYrV0pt20r//KfZXgoAAAAAAACAFYETAKDo+cMfzL5OZcpYx3fskLp2lXbv9sm0t91mup2GD3c/l5go/eUv0rXXStu3+2R6AAAAAAAAoNgicAIAFE19+0rLl0vVq1vHDx2SunWT1q71ybQVKkiffCItXiw1aOB+fvNmqWNH6YUXvL6tFAAAAAAAAFBsETgBAIqu9u2lNWukJk2s4+fOSddfL82f77Opr79e2rlTevJJs9dTRikp0muvmfLWrfNZCQAAAAAAAECxQeAEACjaGjaUVq+WOnWyjickSIMGmXYkHwkPl/71LzN98+bu53/5xazw9/TTUlycz8oAAAAAAAAAijwCJwBA0Ve1qrR0qXTzzdbxtDRpxAjplVckp9Nn00dFSVu3Ss8/LwUFWc85nSaUatNG+uknn5UAAAAAAAAAFGkETgCA4iE8XJozR3roIfdzL70kjR4tpab6bPpSpaRXX5U2bjRL6WW2f79Zhm/ECOniRZ+VAQAAAAAAABRJBE4AgOIjOFiaMkX629/cz330kXTttdL48dKRIz4r4ZprpPXrpX/8w4RQmX3yidSihU+3lwIAAAAAAACKHAInAEDx4nBIr70m/ec/5nFGmzZJTz4p1a1rwqe33jKtR14WFCT95S/S9u1S9+7u548dkwYOlO65Rzp92uvTAwAAAAAAAEUOgRMAoHh67DHpf//Lus1IMm1IY8dKjRqZNfBef13avdurJTRtKi1fLn3wgVSmjPv56dNNt9NXX/l0iykAAAAAAADAdgROAIDia/Bg6ccfpYiInK/bulV6/nmpeXOpVSuz59POnV5JgQICpMcfl3btkm680f38mTPSvfeajqeYmAJPBwAAAAAAABRJBE4AgOKtRw9p3z6zadJDD0kVK+Z8/c8/S6+8IrVpY1qUxo2TNm8ucPhUr560cKE0bVrWJXz7rdSypfTxx3Q7AQAAAAAAoOQhcAIAFH+lSkm33CJNnSqdPCl9/700cqRUtWrOr/v1V+mNN6SOHaWGDaVnn5XWrpXS0jwqw+GQHnxQ+uUX03yV2aVL0qOPStdfL/32m0dTAAAAAAAAAEUSgRMAoGQJDpb69ZM++kg6dkxautSseVezZs6vO3hQeucdqWtXqW5d6U9/klaskFJT811CjRrSzJnmqF7d/fzSpVLr1tK773p0ewAAAAAAAKDIIXACAJRcQUFS797SBx+YDZRWr5aeesoESjk5elR6/32pVy+pVi1p1Chp8WIpOTlf0w8ebLqdHnzQ/VxCgvTMMybf+vnnfN0WAAAAAAAAKHIInAAA/iEgwKQ7775rupk2bJD+8hepUaOcX3fqlOmWuuEG07o0fLj03XfSlSt5mrZSJbOv06JFWedcGzZI7dqZbaWSkvL9rgAAAAAAAIAigcAJAOB/HA6pUyfpH/8w+zht2yY9/7zUvHnOrzt3TpoyRRowQKpWTbr/fmnOHNOulIsbb5R27TKr+2WWnCy99JLZSmrePI+3kAIAAAAAAABs43A6nU67i4BvxcTEqE6dOpKkI0eOKCIiwuaKAKAI++UXadYsc2zfnrfXhIebEOrOO6X+/aUyZXK8fOVK6ZFHpL17sz7ftKlZbu/++6XQ0HzWDwAAAAAAAOTCF7kBHU4AAGTUooX0wgum6+nXX00XVMeOOb8mLk76+mvprrukqlWl22+XvvhCungxy8t79DC3/+tfpcBA9/N79kgjR0r16kmvviqdOVPgdwUAAAAAAAD4FB1OfoAOJwDwgkOHpNmzpZkzpTVr8vaakBCz99PgwdJtt5kNnTLZvNlsC5VTM1Xp0tKwYdJTT0mNG3tYPwAAAAAAAPA7OpwAALBLvXom8Vm9WoqJkd5/X+rdWwrI4T+lSUnSggXSww+bPZ/69ZM++kg6efLqJR06SBs3Sv/9r9SmTda3SUiQPvxQiow02dW6dd59awAAAAAAAEBB0eHkB+hwAgAfOnVKmjPH7Pm0ZImUmpr7awICzLp6gwdLd9wh1a4tSXI6pR9/lN5+2/zMSbdu0rPPSrfemvWyfAAAAAAAAEB2fJEbEDj5AQInACgk585J8+aZZfd+/NF0OOVFVJR0550mfKpfX5JZYu+dd6SvvpJSUrJ/aZMm0tNPSw8+aJbeAwAAAAAAAHJD4ASPEDgBgA0uXjTL6c2cKS1cKCUm5u11HTqY4OmOO6RmzRQTI733nlmJ79Kl7F9WpYr0xz9Kjz0mVa3qnbcAAAAAAACAkonACR4hcAIAm8XGmtBp1izp22+luLi8va5586vh06VG7fTJZIf+/W/pyJHsXxIaKj30kNluKjLSG8UDAAAAAACgpCFwgkcInACgCElIkH74wYRP8+aZTqi8qF9fuuMOpQy8QzMOR+ntdwO0bVv2lzsc0m23mX2eunXzRuEAAAAAAAAoKQic4BECJwAoopKSpCVLzLJ7c+aYPaDyokYNOW8bpG0N79ALS3prwQ/BOV5+7bUmeBo0SAoMLHDVAAAAAAAAKOYInOARAicAKAZSUqQVK6TZs6VvvpGOHcvb6ypW1PkeA/Vp7B16YcUNupxSOttLGzWSnn7aLLkXFuadsgEAAAAAAFD8EDjBIwROAFDMpKVJGzaY8GnWLGn//ry9LCxcu+rcrH8fvkP/SxigWJXN8rrKlaXHHpMef1yqXt2bhQMAAAAAAKA4IHCCRwicAKAYczqlHTtM+DR7trRrV55elhIYomXB/fRF4h2ap4E6p8pu15QqJT3wgPTMM1LTpt4uHAAAAAAAAEUVgRM8QuAEACXI3r2u8Gnjxjy9JEWBWq5emq079I1u13HVcrtm4ECzz1P37pLD4e2iAQAAAAAAUJQQOMEjBE4AUEIdPizNmWPCp5UrzVJ8ebBGUZqtOzRbd+iAGlrOde5sgqfbb5eCgnxQMwAAAAAAAGxH4ASPEDgBgB84dUqaO9eET0uWSMnJeXrZNrW9Gj79rJaSTHtTgwbSU09JDz8shYf7sG4AAAAAAAAUOgIneITACQD8zIUL0oIFJnxauFBKSMjTy/Yo8mr4tEkdJTlUsaL02GPSH/8o1ajh06oBAAAAAABQSAic4BECJwDwY/Hx0qJFJnyaP1+6dClPLzusOvpGt2uWBmu1uikoJFD33y89/bTUooWPawYAAAAAAIBP+SI3CCjwHQAAQNEVFibdcYf0+efS6dOm42nECKlq1RxfVldHNEbvaYV66bhq6v2kkYqZvEjXtEzSLbdIy5ZJfGUFAAAAAAAA6QicAADwFyEh0k03SR9/LB0/Li1fLv3pT1Iu32CpptMaqUlapP46pWoauuA+vddntnp0iNeMGVJKSiHVDwAAAAAAgCKLJfX8AEvqAQBy5HRKmzaZZfdmzZJ+/TVPL4tXaS1Uf62ofIeaPTNA9z9RQWXK+LhWAAAAAAAAFBh7OMEjBE4AgDxzOqWffzbh0+zZ0vbteXpZkoK1Iuh6nbpthPp/fLsqVnL4uFAAAAAAAAB4ij2cAACAbzkcUqtW0osvStu2Sfv2SW+9JUVF5fiyECWrb8oi3TtrsFbUGKJ/P39GcXGFUzIAAAAAAADsR+AEAACy16iR9Oyz0po1UkyM9MEHcva5TmkBgdm+5LbkWbr79dZ6JGKR3n9funKlEOsFAAAAAACALQicAABA3tSuLT3+uBw/LVHAyRNyTp6ic11vUXJAiNulNXVCX13or4A/Pa42jeM1daqUkmJDzQAAAAAAACgUBE4AACD/qlSR4+FhqrR6voLPn9bx16foUkhlt8se14eaF9NOHz68Ua1bSzNnSmlpNtQLAAAAAAAAnyJwAgAABVOunGqOG6Zyh3bpYrf+bqebaq/WqKvu3P2qhg5JUadO0qJFktNpQ60AAAAAAADwCQInAADgHTVqqPzKBdKECUotVdpyKlgpelUvaqV66OKWferfX+rVS1q1yqZaAQAAAAAA4FUETgAAwHscDmnUKAXu2CZnp05up6O0Ttt0jR7RJK1c6VSPHtLNN0tbt9pQKwAAAAAAALyGwAkAAHhfZKQcq1dLL70kZ2Cg5VQZxWmSRmqublM1ndTChVL79tJdd0m7d9tULwAAAAAAAAqEwAkAAPhGcLD08ssmeGrc2O30QM3XTrXWrZonSfrf/6SWLaXhw6VDhwq7WAAAAAAAABQEgRMAAPCtLl2kbdukRx91O1VNpzVPt+ljjVC4YpWWJk2ZIkVGSmPGSCdPFn65AAAAAAAAyD8CJwAA4Hvh4dLEidK330rVqrmdHqFPtF1tFaU1kqSkJOm996SGDaW//U06f76wCwYAAAAAAEB+EDgBAIDCM2CAtGuXdNttbqcaab9Wqode1fMKUrIkKT5e+r//M8HTG29IcXGFXTAAAAAAAADygsAJAAAUrqpVpW++kSZPlsqUsZwKVJqe1+taqyg1U/TV8QsXpHHjpEaNpA8+kK5cKeSaAQAAAAAAkCMCJwAAUPgcDunhh6Xt26WuXd1Od9RmbVF7Pa4PJDmvjp88KT3xhNS0qTRtmpSSUnglAwAAAAAAIHsETgAAwD4NG0orVkivvy4FBVlOlVaiPtATWqSbVFPHLOcOHZKGDZNat5ZmzpTS0gqzaAAAAAAAAGRG4AQAAOwVGGjWy1u/Xmre3O30jfpBu4Nba7Bmup3bvVsaMkTq1ElatEhyOt0uAQAAAAAAQCEgcAIAAEVD+/bS5s1mzbxMyiWf00wN0cJqD6icLrqd37JF6t9f6tVLWrWqMIoFAAAAAABARgROAACg6ChdWnrvPen776VatdxO33TqM52o1kaPNFme5ctXrpR69JBuvlnautXXxQIAAAAAACAdgRMAACh6+vWTdu406+VlUvrUYX28r492Dxyr1pFXsnz5woWmYeruu6U9e3xdLAAAAAAAAAicAABA0VSpkjRjhvTZZ1K5cpZTDqdTTee9pe2lOuubV3aqXr2sb/H111KLFtLw4dKhQ4VQMwAAAAAAgJ8icAIAAEWXwyHdd5/pdurd2/30zh0a9FpH7XvsXb0/Pk3Vq7vfIi1NmjJFioyUxoyRTp70fdkAAAAAAAD+hsBJ0qFDh/TMM8+oWbNmCg8PV6VKldSpUye99dZbio+P98mc8fHxatiwoRwOhxwOh+rXr++TeQAAKBHq1pWWLJHeeksKCbGeS0pS0F+e0R/n9NX+ZYf1xhtShQrut0hKMttDNWokPf+8dOFCYRQOAAAAAADgH/w+cJo/f77atGmjd999V3v27FF8fLzOnz+vTZs2aezYsWrXrp327dvn9XlffPFFHThwwOv3BQCgxAoIkJ59Vtq4UWrd2v380qUKu7aN/lrnCx3Y79Tf/iaFhblfFhcnvf661KCB9I9/mOcAAAAAAAAoGL8OnLZu3aq7775bly5dUpkyZfT6669rzZo1WrJkiUaMGCFJ2rt3rwYMGKDLly97dd5///vfCg0NVdmyZb12XwAA/EKbNtKGDSZ8cjis5y5elO67TxVG36PXnj6n/fulP/3JvSlKMh1Ozz1nOp4++EC6cqVQqgcAAAAAACiR/DpwGjNmjBISEhQUFKQffvhB48aNU1RUlK677jp9/PHH+uc//ynJhE7vvPOOV+ZMTU3ViBEjlJqaqnHjxqlSpUpeuS8AAH4lNNQsr/fTT1KdOu7nZ8yQWrdW9R0/avx4ae9e6eGHTZNUZidPSk88ITVtKk2bJqWk+Lx6AAAAAACAEsdvA6cNGzZo5cqVkqThw4crKirK7ZpnnnlGzZs3lySNHz9eycnJBZ53/Pjx2rx5s5o2baq//OUvBb4fAAB+rXdvaccO6b773M8dOyb16yeNGaN61RI0ebL088/SXXdlfatDh6Rhw6SGDc1Se2fO+LRyAAAAAACAEsVvA6c5c+ZcfTxs2LAsrwkICNADDzwgSbpw4YKWLl1aoDkPHTqkF198UZI0ceJEhWS1vg8AAMifChWkzz4zXU0VK7qff+89qUMHacsWNWtmLtuyRbr55qxvd+SIWWqvTh3pkUek7dt9Wj0AAAAAAECJ4LeB06pVqyRJ4eHh6tChQ7bX9erV6+rj1atXF2jOxx57THFxcbr//vvVu3fvAt0LAABkctdd0s6dpqsps+hoqUsX6Y03pNRUtWsnLVggrVwp9eiR9e0SE6XJk6VrrjGNVLNns9weAAAAAABAdvw2cIqOjpYkNW7cWEFBQdle16xZM7fXeGL69On67rvvVLFiRa/tB5UuJiYmx+P48eNenQ8AgCKrdm1p4ULT1RQaaj2XkiKNGyf16iXt3y9J6t5dWr5cWrRIymJ13auWL5cGD5YaNZL++U/p3DkfvgcAAAAAAIBiyC8Dp8TERJ35fWOGiIiIHK+tWLGiwsPDJUlHjhzxaL7z58/rySeflCT94x//UNWqVT26T3bq1KmT49G5c2evzgcAQJEWECA98YRZN699e/fzq1dLbdtKU6ZITqccDunGG6U1a6QNG6T775eCg7O+9eHD0l/+IkVESCNHmoYqAAAAAAAA+GngdPny5auPy5Qpk+v16YFTbGysR/P9+c9/1smTJxUVFaURI0Z4dA8AAJBPzZtLa9dKf/ubCaEyio2Vhg+X7rhDOn366nCnTtKnn5pg6e9/l2rUyPrWCQnSpElSmzbSdddJc+ZIqam+eysAAAAAAABFnV8GTomJiVcfh4SE5Hp9qVKlJEkJCQn5nmvFihWaMmWKgoKCNHHiRDkcjnzfIzdHjhzJ8diwYYPX5wQAoFgICZFee01asUJq2ND9/Jw5UuvWZkOnDGrUkF58UTp0SPr8cymnZuGlS6Xbb5caN5befls6f967bwEAAAAAAKA48MvAKTTDng5JSUm5Xn/lyhVJUunSpfM1z5UrVzRy5Eg5nU6NGTNGbdq0yV+heRQREZHjUbNmTZ/MCwBAsdGtm7Rtm+lqyuzkSemWW6TRo6W4OMupkBDpD3+Q1q+X1q0zj7Nbbu/gQenPfzbL7Y0aJf38s9ffBQAAAAAAQJHll4FT2bJlrz7OyzJ5cb9/+JSX5fcyev3117Vnzx7VqVNHf//73/NXJAAA8K6yZaVPPpG++UaqUsX9/MSJUrt2pk1p9WopQ0e0JHXpYrqdDh0y3U/VqmU9TXy89NFHUqtWUt++0rx5LLcHAAAAAABKviC7C7BDaGioKleurLNnzyomJibHa8+fP381cKpTp06+5nnzzTclSX379tX8+fOzvCb93nFxcZo+fbokqVq1arruuuvyNRcAAMijQYOkqCjT7ZRpKT39+qtpU5JMK1P79lLXruaIipJq11bNmmZ/p3HjpK+/lsaPlzZvznqqJUvM0aCB9Mc/Sg8/LFWo4Ms3BwAAAAAAYA+H0+l02l2EHXr27KmVK1cqPDxcFy5cUFBQ1tnb2rVr1bVrV0nSiy++mK9OJU/3a+rVq5eWLVvm0WuzEhMTczUsO3LkiCIiIrx2bwAAii2nU5o0SXrqKdOWlBd165rgKT2EattWzqBgrVsnvfeeNHOmlJKS/cvDwqQHH5SeeEJq3tw7bwMAAAAAACC/fJEb+OWSepLUvXt3SaazaHN2X0uWtHz58quPu3Xr5vO6AABAIXE4pJEjzd5OXbrk7TWHD0szZkhjxkidOknly8vRu5ei5v5VX90zT4c3n9bzz0tVq2b98vh4acIEqUULqV8/6dtvpbQ0b70hAAAAAAAA+/hth9OGDRvU5fcPlx599FFNnDjR7Zq0tDS1atVK0dHRqlChgk6dOqXg7HYK91D9+vV16NAh1atXTwcPHvTqvdPR4QQAQC5SUqQ5c6TFi6U1a6Rdu0wHlCcaN1Zq5yhtCOqqf2/oqpm7WypNgdle3qiRWW5v2DCpfHnPpix2UlNNeLd3r1nGcO9e1xEfbzbASu8iu/Za1iEEAAAAAMDLfJEb+G3gJLmW1QsKCtKKFSsUFRVlOf/WW29p7NixkqSXXnpJL7/8suX8smXL1KdPH0nSgw8+qGnTpuW7BgInAACKoEuXpPXrpbVrTQC1bp108aJHt0oJK6tfynbRvFNRWuXsqnW6VhdVwe268HDpoYdM+NSsWcHKLxKcTunECfdA6ddfpX37pKSkvN+rRQvrXlpNm5oONQAAAAAA4BFf5AZZb1zkJ8aPH69u3bopISFB/fr107hx49SnTx8lJCRo+vTp+vjjjyVJkZGReuaZZ2yuFgAAFJpy5aQbbjCHZNa9i4424VN6CLVnT55uFRR/WW3iF6uNFl8d+1kttEZdtVZRWqOu2qtIxcUF6D//kf7zH+nGG6U//Um66SYpoKgvgHzhgjVMyhguxcZ6Z45ffjHHJ5+Y55UqmeApfT+tTp2kMmW8MxcAAAAAAPCIXwdO7dq104wZM3Tffffp0qVLGjdunNs1kZGRWrBggcqWLWtDhQAAoEgICJBatjTHiBFm7OxZ0/mUHkKtX2+Wg8uDlvpFLfWLRsgEKGdVSet07dUQatX3nfX992XUuLH0xBOm86lcOR+9t7xISDBdSRnDpPSA6fTpwq/n3DlpwQJzSFJgoNS2rSuA6tpVqlePLigAAAAAAAqRXwdOknTrrbdqx44dGj9+vBYsWKCYmBiFhISocePGGjJkiP74xz8qLCzM7jIBAEBRU7myNGCAOSSzD9TOnSaASg+hDhzI2610TgP0nQboO0lSqgK0Q220Zl9XrR0TpUnPdVWfhxvoj084FBnpo/eTnCwdPJh1p9KRI76Zs1w5szxekyZSZKQ5QkJcyxlu3ChduZL7fVJTpS1bzPGf/5ixGjVc4VPXrlL79lKpUr55HwAAAAAAwL/3cPIX7OEEAIBNTpxwLcG3Zo20eXPeApSsbqXqWqsonWvaVS0fiVLn0R0UEF46fzdJS5OOHs16X6X9+01o5m2lSlkDpchI1/OqVXPuQkpKkrZudQV4q1dLx455VkdIiNShg2sfqK5dpZo1PbsXAAAAAADFnC9yAwInP0DgBABAEXHliglQMoZQHgYoSQrWufrtVenmKIX0/j1EiYiQnE6z3F9W+yr9+qtZHs/bAgOlBg2sYVL6ERHhvY2onE7TbZVxL62tW02Hkyfq17cGUG3aSEF+vwAAAAAAAMAPEDjBIwROAAAUUVkFKNu2ed5pVKuWCZTOn/dqmVfVrm0Nk9IDpgYNTAeRHeLjpU2brEsZnjnj2b3CwqTOnV3L8F17rVk6EQAAAACAEobACR4hcAIAoBjJGKCsXavUVWsUeM7DAMUTlSu7L30XGSk1biyFhxdeHZ5yOqV9+6wB1K5dZtwTTZu6AqioKKl5c+91bAEAAAAAYBMCJ3iEwAkAgGLM6ZR++01Xlq7R/s/XKGDDWjVJ3KkAFeCvcOHhWe+r1KRJyezouXhRWr/e1UW2bp106ZJn96pQwXQ+pQdQXbpIZct6tVwAAAAAAHyNwAkeIXACAKDkcDqllQsuackbG6Q1a3St1ipKa1VBFy3XJSlYv6mR9gdGytkkUrV6NVGLQZEKbRMp1awpORw2vYMiIDVV+uUX615av/7q2b0CAqTWrV37QHXtKjVs6N9/vgAAAACAIo/ACR4hcAIAoGQ6cED68ENp8qQ01bwYrVbapYsqr1/VRIdUT6kKslwfFibdfLM0eLA0YACNORanT5vOp/QAauNGsx+WJypXltq3l9q1M0f79mZJQpbiAwAAAAAUEQRO8AiBEwAAJVtcnPTZZ9K0aWbluLwoVUq68UbpzjulW281K8Uhg+Rkaft21z5Qa9ZIhw97fr8yZaS2bV0BVLt2UosWUkiI92oGAAAAACCPCJzgEQInAAD8x5Ej0jffSDNnSqtWmSX4chMcLPXta8Kn224rmds4ecXRo9Zl+LZsMcGUp0JCpFatrJ1QbdqYPbYAAAAAAPAhAid4hMAJAAD/dOKEK3xatkxKS8v9NYGBUp8+JnwaNEiqXt3XVRZjCQkmdEoPoNaskU6dKtg9HQ6paVNrJ1S7dlKlSt6pGQAAAAAAETjBQwROAADg9Glp7lwTPi1ZIqWk5P6agACpRw8TPt1+u1S7tu/rLNacTungQRNCbd3q+nniRMHvXa+eK3xKD6Nq1TIBFQAAAAAA+UTgBI8QOAEAgIzOn5fmzZNmzZK+/15KSsrb67p2NeHTHXeY/AN5dPy4CZ4yHvv3F/y+Vau6d0I1amSSQgAAAAAAckDgBI8QOAEAgOxcuiR9+60JnxYuNKvE5UWnTtLgweZo3Ni3NZZIFy5I27ZZO6Gio/O27mFOypaVrrnG2gnVvLnZqAsAAAAAgN8ROMEjBE4AACAv4uJM6DRzpgmh4uLy9rprrjHB0513Ss2a+bTEki0+Xtq509oJtWOHdOVKwe5bqpTUqpW1G6pNGykszDt1AwAAAACKHQIneITACQAA5FdCgvTDDyZ8mjfPdELlRYsWJni6806TcbDFUAElJ0u7d1s7obZty/v/INkJCDDpYMZ9odq1kypW9ErZAAAAAICijcAJHiFwAgAABXHlirRkiVl2b84c6dy5vL2uSRMTPA0ebBprCJ+8JC1NOnDAFUClh1GnThX83vXrm+Cpc2ezaVfHjnRCAQAAAEAJROAEjxA4AQAAb0lOlpYtM+HT7NnS6dN5e139+q7wqXNn02ADL3I6pePHrQHU1q3SwYMFu29QkNS2rRQV5Trq1yc9BAAAAIBijsAJHiFwAgAAvpCaKq1aZZbdmzXL5B15ERFhgqfBg00TTWCgb+v0a+fOmSX4Mu4LtXu36ZLyVI0a1gCqQwepdGmvlQwAAAAA8D0CJ3iEwAkAAPhaWpq0bp0rfDp8OG+vq1FDuv120/3Us6dpqIGPxcdLO3ZYO6F27pSSkjy7X3CwdM01Jnzq2tX8rFOHLigAAAAAKMIInOARAicAAFCYnE5p0yZX+PTbb3l7XZUq0qBB0j33SL17s+xeoUpOlqKjTQC1caO0dq0JpVJTPbtfrVrWLqj27aXQUO/WDAAAAADwGIETPELgBAAA7OJ0Stu3m+Bp5kyzmlteRERIf/iDdP/9UsuWvq0R2YiLc4VPa9aYn2fPenavkBATOmUMofg7KQAAAADYhsAJHiFwAgAARcUvv5jgaeZMs4pbXrRrJz3wgOl8ql7dt/UhB06ntG+fCZ7Sj507Pd8PKiLCugxfu3YmmAIAAAAA+ByBEzxC4AQAAIqivXtN59OsWdLmzblfHxgo9etnup5uu00KC/N9jcjF5cvShg2uAGrdOuncOc/uVaqU1KGDtQuqVi3v1gsAAAAAkETgBA8ROAEAgKLuwAHT9fTFF2YJvtyULSsNHmw6n3r1Yr+nIsPpNEliegC1Zo30889m3BP16lkDqGuukYKDvVoyAAAAAPgjAid4hMAJAAAUJzt2SJ99Jn35pXTsWO7X16nj2u+pRQvf14d8unjRvQvqwgXP7hUaKnXs6FqGLyqKdRYBAAAAwAMETvAIgRMAACiOUlOln34y4dPs2VJcXO6vad/eBE/s91SEpaVJu3db94L65RfP79eggSt86tpVatNGCgryXr0AAAAAUAIROMEjBE4AAKC4i42V5swx4dPixSazyElgoHTjja79nkqXLpQy4akLF6T1613L8K1fL1265Nm9wsKkzp2lnj3NeotRUfwDAAAAAACZEDjBIwROAACgJDl2zCy399lnZvm93JQtK915pwmf2O+pmEhNlaKjrV1Qu3d7dq/gYKlLF/M/fq9epgsqPNy79QIAAABAMUPgBI8QOAEAgJIqfb+nL76Qjh/P/fq6dV37PTVv7vv64EXnzpn9n9IDqPXrTetbfgUFSZ06uQKobt1MKgkAKBlOnpR27ZJ27pQOHpQiIqS77jJ/CQAAAFcROMEjBE4AAKCkS02Vlixx7fcUH5/7azp0cO33VK2a72uEl6WmSj//7FqGb+1a6ddf83+fwECz+Vfv3iaA6t5dKl/e6+UCALzs8mXz34H0cCn95+nT7tc6HNINN0gPP2zW2g0NLfx6AQAoYgic4BECJwAA4E9iY6VvvnHt95Tb33YDA6WbbjLh08CBbPdTrJ05Y4KnFSuk5culLVtMMJUfAQHSNde4AqgePaSKFX1RLQAgL5KSpL17raHSrl3SgQOe3a9iRdPuPHy4+X0PAICfInCCRwicAACAvzp61LXf086duV9frpxrv6eePdnvqdi7dElavdqET8uXS5s2SSkp+buHwyG1aWPCp969zT8YlSv7pFwA8GtpadKhQ+4dS3v2SMnJvpmzXTvT9XTvvVKlSr6ZAwCAIorACR4hcAIAAJC2b3ft93TiRO7X160r3XefCZ+aNfN9fSgEsbFm+b30AGrDBs8+xGzVyhpAsSYjAOTP6dPuHUu7dnm2N19WSpeWWrQw/zFfssR8ASEnISHS7beb8On66037MwAAJRyBEzxC4AQAAOCSkuLa7+mbb/K231PHjiZ4GjqUbKFEiY+X1q2Tli0zAdS6dWbppvxq3twEUOlHzZpeLxUAiqXYWOmXX6zh0s6d0qlT3rl/QIAUGWm+CNC6tTlatZIaNnSFRvHxZoPHKVOkpUtzv2edOtJDD5mjYUPv1AkAQBFE4ASPEDgBAABkLTbWfAb12WcmhMrrfk8PPCDdeiv7PZU4iYnS+vWuAGrtWjOWX5GR1gCKv38DKOmSk80+SxlDpV27pP37vTdHRIQrUEoPl5o1k0JD836P/fuladOkqVOlmJjcr+/Tx3Q93XGHFBbmcekAABRFBE7wCIETAABA7mJiXPs97dqV+/XlyklDhpjOpx492O+pRLpyRdq40YRPy5aZ5fjy0hKXWaNG1gCqXj2vl1qkOJ3m4F8KoORxOqXDh907lnbv9t4+SxUqWLuV0n9WqOCd+0tSaqr5psmUKabdObfu1nLlpHvukYYPN23PDof3agEAwCYETvAIgRMAAEDeOZ2u/Z6+/DJv+z3Vqyf94Q/s91TiJSVJmze7AqjVqz3bb6R+fWsA1aCBPR9eOp0mVIuNNUdcXNaPc3ue1bnAQLPUYLt20jXXmJ9t20oVKxb++wTgmYsXpa1b3fdaunzZO/cPDTX7LGUMlVq3lmrVKtzfiefOmf/gT54sbduW+/WtWpmup/vuk6pW9Xl5AAD4CoETPELgBAAA4JmM+z3Nni0lJOT+mnbtzLJ7N9wgde0qlSrl+zphk5QUacsWVwC1alXuG9NnpU4dawDVuLH7h61JSZ6HPzldm5rqlT+KPKtf3xVApYdRERF0C5RUTqf55+ziRfPvxsWL1seZf2Yeq1xZuuUW6e672UunsMTGSvPmmQDm++/N77mCCggwv9cyL4fXqJFrn6WiYutW0/X0xRfS+fM5XxsUJA0caMKnG280zwEAKEYInOARAicAAICCu3zZtd/TTz/lvt+TZPZ46tlT6tvXBFCtW7PKWImWmmq+HZ8eQK1cKV24kP/71KwplS9vDYq88aFvUVW5siuESv8ZGcmHt3ZLSspfOJTVuUuXpLQ079TTubM0dKh0111S7dreuSeMpCRp0SLpq69M2OTJ0qHpatd271hq3rz4bXqYmCjNnWvCpx9/zP0/+jVrSg8+KA0bZn5/AQBQDBA4wSMETgAAAN6Vvt/Tp59KP/+c99dVrWrCp/QA6ve/oqGkSk01S1AtX+46zp2zu6riITRUatPGGkS1aSOFhdldWfGQlCSdOuUeDOUnOEpMtPtdZM3hMBvn3XOPNHgwS5p5KjVVWrHChEwzZ+bezZNZ+fLueyy1aiVVquSbeu10+LD03/+a8Ongwdyv797ddD0NGSKVKePz8gAA8BSBEzxC4AQAAOAbTqdpaEnf7+nkyfy9PjLSBE99+0p9+pjP71CCpaWZhDJjAHX6tN1VWYWFSeHh5kPSMmWsjzM/z+m6ixfNvxzbtpklqnbtkpKTC1ZbQID5lyZjJ1S7dlKVKl5448VIfLx09KhJvrM6jh7N/y+j4iow0PwCHTpUGjRIqlDB7oqKNqfT7EP35ZfSjBnSsWO5vyY4WGrZ0j1c8selMNPSzO/tKVNMSJdbKBsebpaDHD5cioryvz8vAECRR+AEjxA4AQAA+F5KillB7ccfpcWLpU2b8rbsXrqAALNiVHoAde21UkiI7+pFEeB0StHR1gDqxIm8vTY0NH+BUF7CorAw3+2nkpRk3mt6AJUeRl28WPB7165tDaGuuUZq0KD4fbjrdJrOopzCpJiY/HeiFCVhYSZZL1cu658ZH5cubTpwZs6Uzp7N/d4hIVL//iZ8uvVW8881jN27TSfTl19K+/blfn1goPmP0T33mCCvXDmfl1jsXLhgQrvJk6WNG3O/vmlT0/V0//1m+T0AAIoAAid4hMAJAACg8J07Z/Z6WrzYhFD79+fv9eHhUq9ergCqZcvi9/k58snplPbuNUFMQED2wVFYWMnY38jplA4csIZQW7eawKWgypVz3xeqeXP7Ulyn04Qm6R1I2YVJsbH21JebwEBXIJTXwCirn578c5ucLC1ZIk2fLn3zjQnlchMWZkKnoUOlm24yAa2/OXLEBCJffmn+vcqLbt2ke++V7rxTqlbNt/WVJDt3SlOnmnbnM2dyvjYwULr5ZhM+DRhgOsgAALAJgRM8QuAEAABgv/37Tfi0eLH57DS/W/nUqOHa+6lvX6lWLd/UCdju9Gnrcnzbtkl79pjlrAoiJMQktxmDqLZtC969kZpq9kvKvKxd5jDpypWCzeOpMmXyHgpld6506aKReCcmSosWmfBp3jwpISH315QrJ91+uwmfrr++ZH/Af+aM6Qj76ivTHZYXbdqYkGnoUKlePd/WV9IlJUnffmuW3Fu4MPffWdWqmY6nhx+WWrQonBoBAMiAwAkeIXACAAAoWlJTzWfo6cvvrVqV/8+iW7RwBVC9eklly/qkVKBoiI83XQQZO6F27Mh9D5W8aNTIfUm+mjVNwJKcLB0/nvU+SemPjx0za2oWtvLlzT46WR21a5tUukIF3y2TaLfYWPPh/vTp5sP9pKTcX1O5suneGTpU6tGjZPzZxMZKc+eaTqYffsjbP4sNG5rl8u65x4Sw8L5jx6RPPzXh06+/5n79tdea4Onuu1nCEABQaAic4BECJwAAgKItPl5avdoEUD/+aD5Pz4+gIPNZVXoA1alTyf4SPyDJfLC+d681hNq6Nf/tg1mpVs2EESdO5G8zNm+pWtWERjkFSmXKFH5dRdWFC9KcOSZ8WrzYpPq5qVlTuusuEz516VI0Orjy6soV6fvvTciU106v6tXNe73nHrNhYHF6v8WZ02n+Az9livT111JcXM7Xly4tDRliwqeePQv/fyen0/zzlZBgjvj4rB/n51xCgvmddsMNZjnB3z+fAgDYj8AJHiFwAgAAKF5Onzb7P6UHUIcP5+/1ZctKffq4AqimTflsEX7C6TRdR5n3hTp40ObCfudwmKAjPTTKKkyqVcs/9xzyltOnpVmzTPi0YkXeAsN69UwYM3SoWWaxKP7CTE2Vli83y+XNnGlCttyULy8NHmyWzOvdu2R0dBVnly9L//ufNHmytGZN7tc3aiQNG2aW3atY0fPAJ7cwKPNzX39M2Lq1CZ5uvlmKiuIbMgBgIwIneITACQAAoPhyOqV9+1zL7/30k3TxYv7uERHhCp+uv9580R3wKxcuuO8L9csv3l0KLyjIFSJlFybVqMGHq4Xp6FHzAf/06dL69Xl7TdOmJni6+26peXPf1pcbp1PatMl0Ms2YYZZ3zE1oqDRwoOlk6t9fKlXK93Ui/3bvlqZOlf77X+nkSbursU/58lK/fiZ86t+fv6AAQCEjcIJHCJwAAABKjpQUafNmVwC1Zo3ZZiY/2rRxBVA9ekjh4b6pFSjSEhNN6JSxE2r7drMnTmahoe5L2mUOk6pVkwICCv1tII8OHDChzfTp5n/nvGjb1hU+NWjg2/oyio42nUxffWW+cZCbwEDzof2990q33camfsVJcrK0aJFZcu/bb+3ZD64o6djR1f3UsSNdeQDgYwRO8AiBEwAAQMkVGyutXOkKoHbuzN/rQ0Kkrl1NANW3L5/vwM+lpUm//WaCqMBAs9dIRIRUqVLRXGYNnomONuHTV1+ZfcDyoksXEz4NGWICR287fNiEYV99lfeN/Lp3NyHTnXeaPXJQvJ08KX3+uVlyLzra7mqsSpeWwsLMz/Qjp+cZHwcHSxs2mGAtP3vsValiup5uvtkEqpUq+e79AYCfInCCRwicAAAA/MeJE9KSJa79n44dy9/rK1Qwn2F27WqOTp3M50YAUOI4nabbafp0cxw6lPtrHA6pZ08TPg0eXLCg58wZs+TfV1+Zbw7kxTXXmOXyhg6V6tb1fG4UXU6nCWimTDH/bFy+7H5NcHDeA5+CnitVyjuBe2qqWdryu+/MsXVr3l8bEGD2e0rvfiqqe60BQDFD4ASPEDgBAAD4J6fTbBOxeLEJn5Yty/pzq5wEBZnPN6OiXCFUnTp8zgOghHE6zYfh06dLX3+dt/2SAgNNa+jQodKgQSaxz83ly9LcuWZfph9/zNsSao0amU6me+6xf18pFK6kJNP9FhxsDYRKQivysWPSwoUmfPrxx/z9BaVWLVf41Lcvy0gCgIcInOARAicAAABIZquIDRtcy++tW2e+cJxftWu7wqeuXU0gFRLi9XIBwB6pqabjaPp0aeZM6ezZ3F8TEmKW/xo6VLr1VuvmeFeumOXEvvxSmj9fSkjI/X41aph73XuvWeuUlB8lWVKStHq1CZ8WLMjfkoLBwWZDyptvlgYMkJo25d8XAMgjAid4hMAJAAAAWbl0SVq+3BVAebplRGio+Tw0PYCKipKqVfNurQBgi+Rks07p9OnSN9+YX5y5CQszodNNN0mrVkmzZkkXLuT+ugoVzDJ9994r9epVMrpYAE8cOODqfvrpp7yFtOkaNHB1P/Xu7Z/rAjud0vnzpjvu0CFXl1zv3lKzZnZXB6AIIXCCRwicAAAAkBcxMeZL/WvWmGP7ds86oCSpcWNrF1SLFnx2CqCYS0w0nUrTp0vz5uXvQ/DslC4tDRxolsu76SazXw4Al4QEsyZwevfTgQN5f21oqNSnj+l8uvlmE0aVBCkpZknCjIFS5p+xsVm/NjLS/M4ZOND8BY2/nAF+jcAJHiFwAgAAgCdiY6WNG034tHat+Xn+vGf3KldO6tLFFUB16SKVL+/degGg0MTGSt9+a8KnhQvNkmB5FRQk9etnOpkGDmT/GSCvnE5p715X+LRihelCzKtmzVzdTz16FN31gOPicg6TYmI8/0ZQRpUrS7fcYn4P9esnlSlT8HsCKFYInOARAicAAAB4Q1qa+ZwnvQNqzRrPl+FzOKRWraxdUI0ase0CgGLowgVpzhwTPi1enP0HwT17mk6mO++UqlQpzAqBkunyZbPk5XffmePo0by/tkwZ6YYbTPjUv7/ZoLIwOJ3S6dPWEClzoJSXfeO8rVQp6frrTfh0661SrVqFXwOAQkfgBI8QOAEAAMBXzp2T1q1zdUCtX2++mOuJqlXN/k/pAVTHjma1KQAoNk6fNns2TZ8u/fabVKOGdNdd0tCh0u//vxyADzid0s6dpvPpu+/MX0rS0vL++rZtXUvvdeliOhE9kZRkOpCy6046fNgsz1kYHA4THNWpY+Y9dizvr+3YUbrtNhNAtW7NN4KAEorACR4hcAIAAEBhSUkxn/dk7II6eNCzewUFSe3buwKoqCiJv8oCAIBcnT8v/fCDCZ8WLjRhcF5VrCjdeKMJn266yXwjJt3Fi9mHSYcOScePm/CrMISGSnXrSvXqmSP9cfrP2rVdywY6ndLmzWb/ublzpR078j5P/fqufZ969pSCg33ydgAUPgIneITACQAAAHY6dsx0QKV3QW3enL/tTjKqU8e6DF/btnzuAQAAcpCWJm3a5Fp6b+PGvL/W4ZDatTN7RR06JF265Ls6M6tSxT1EyvizalXPO48OHpTmzzcB1LJl5htDeVG+vAniBg40YVyFCp7ND6BIIHCCRwicAAAAUJQkJkpbtli7oE6e9OxepUtLnTu7Aqhrr2VrFAAAkIOTJ6VFi0z49P33pmupsAUGmrbtjCFSxsd16kjh4YVTy4UL5s9j3jzzZ5LXP4+gIKlXL7P03q23mk4oAMUKgRM8QuAEAACAoszpNF+0zRhA7diRv60XMmrUSGrWTGra1HVERpqtVNiCAAAAXJWSYlqwv/vO7P+0c6d37lumTPZL3dWta/ZWCgz0zlzelJQkrVzpWnrv0KG8v7ZNG9e+T+3bSwEBvqsTgFcQOMEjBE4AAAAobi5fljZscAVQa9cW/AvI5cqZ4Cky0hpGNWlSeF8iBgAARdiRI2bPp+++kxYvluLisr6uZs2cl7urUKH4f8vF6TQBXHr4tGlT3l9bq5Zr36c+fcx+UwCKHAIneITACQAAAMVdWpoUHe3aB2rNGmnPHu/dPyLC1QmVsSuqXr2i+QVkAADgY1euSCtWSLt2mQApPUyqU0cqVcru6grf0aPSt9+a8GnJkrxvyBkebvZ7GjjQ7P/E2sdAkUHgBI8QOAEAAKAkOnNGWrfOFUBt2CAlJHh3jlKlpMaNsw6jKlf27lwAAADFQmys9MMPJnz69lvp3Lm8vS4gQOre3dX91KSJb+ssLGlp5s/g9Gnp1ClzZH585Yr5C2Tr1mb5webN6fyC7Qic4BECJwAAAPiD5GSz99Mvv5jup/Tj11+lxETvz1e5sjWASn/cqJF/fvEZAAD4ofR9sObONce+fXl/bfPmrvCpS5ei01budJq1nLMKjjI/Pn3afAsqNTV/cwQGmr84pgdQ6UedOsV/OUYUGwRO8AiBEwAAAPxZWprZkmHPHmnvXlcQtXevdPiw+UzBmwICpPr13YOopk3NlgZ8hgAAAEokp9P8JWvuXLP309q1ef+LVrVq0i23mPDphhuksDDv1hUXl3twlHEsOdl78+dH+fLWEKp1a6lVK7MZKeBlBE7wCIETAAAAkLWEBNMBlTmM2rPHfLHV28LDXSFU5iX6ypb1/nwAAAC2OXXKLLk3b55Zgi+vax+HhprQaeBAE0LVqOF+TUJC9mFRVo990e5emBo0cAVQ6WFU48ZFpysMxRKBEzxC4AQAAADkj9NpPqPIqitq3z6zeoy31azpCqDatJE6dzY/Q0K8PxcAAEChSkiQFi824dP8+dLJk3l7ncNh/lJUrZo1RIqN9W29nipf3tRatar5mf5YknbtMus/HzjgnblCQ6WWLa1L8rVu7ZoPyAWBEzxC4AQAAAB4T0qK+ZwgqzDq+HHvzlWqlNSunfmcJf1o3Jhl+QAAQDGWliZt2GDCp3nzpJ9/trui7IWHZx0gZfW4SpW8beR56ZIJn3buNAHUjh3msbfa62vUsAZQbdqY/bLYZBSZEDjBIwROAAAAQOG4dMkVQmUOo+LjvTNHxYrWACr9S78AAADF0m+/ucKnlSul1FTfzVWqVO7BUfrjqlW9u5dUTpxOs+loxgBqxw7zF0lv/HkEBkrNmlmX5GvTRoqI4JtMfozACR4hcAIAAADs5XRKR49mvVfUwYN53087O/XqmeCpSxfzs31784VcAACAYuXsWWnhQhM+LVyY+9J5QUF5C47Sx8qUKV4BS2KiFB1t7YbasSPvSxLmpnx59yX5WrVic1E/QeAEjxA4AQAAAEVXYqL5Ym96GPXzz2aVmb17Pb9nQID5rCC9A6pLF6lFC/OZDAAAQLFw5Yq0bJm0Zk32wVKFCsUrQPKWU6dcIVT6z59/Nn+x9IaGDa1L8rVpIzVqZDqlUGIQOMEjBE4AAABA8XP+vLRpkwmfNmyQ1q8v2JdZw8KkDh2sS/HVq+efn9EAAACUOCkp0r597t1QBw965/5BQVLt2lLdulKdOuZn5sfly/OXy2KEwAkeIXACAAAAir/0pf3TA6gNG0wgFRfn+T2rVbMGUJ06SZUqea9mAAAA2OzSJWnXLvf9oS5d8v5cZcpkHUSlP46IMPtooUggcIJHCJwAAACAkik11Szrv369K4TaubNge0s3aWINoa65RgoN9VrJAAAAsJvTKR0+bA2gduwwazynpfl27urVc+6SqlbNrA8NnyNwgkcInAAAAAD/ER8vbd3qWoZvwwbpwAHP7xcUJLVt69oLqnNnqWlTPgcAAAAocRITzbeZMndDFWRd5/wKCTGdUNmFUnXqSOXKFV49JRiBEzxC4AQAAAD4t9OnpY0brSHUuXOe369cOaljR1cXVJcuUq1a3qsXAAAARcjp02YvqMOHzRrPhw9bH584Ubj1lC+fdRCVPla7thQcXLg1FUMETvAIgRMAAACAjJxOaf9+635QW7aYL7V6qnZt61J8UVFS6dLeqxkAAABF1JUr0tGj7kFUxnDq8uXCq8fhkGrWzLpLqmlTqUWLwqulCCNwgkcInAAAAADkJjnZrJqSMYT65RcTTnmiVCmpWzepb19ztG8vBQZ6t2YAAAAUExcvugdSGR/HxEgpKb6v4+abpQULfD9PMUDgBI8QOAEAAADwxOXL0qZN1hAqJsaze1WoIPXp4wqgmjQxXz4FAAAAlJpq9orKqUvq9OmCzzNqlDRhQsHvUwL4IjcIKvAdAAAAAAAlUtmyJiTq08c1duyY2Q8qfS+ojRulS5dyv9eFC9I335hDMiuaXH+9CZ+uv16qUcMnbwEAAADFQWCg2RS0Vi3p2muzviYhwXz7KbsuqcOHpfj4nOf5PWCBbxA4AQAAAADyrFYt6bbbzCFJaWnS3r2uDqj1681+UGlpOd/nyBFp2jRzSFKrVq7wqVcvE3YBAAAAV5UubdrkmzTJ+rzTKZ0/n/PSfQ0aFG7NfoYl9fwAS+oBAAAAKEwXLkjLl0uLF5tj9+78vT4oSOrSxbX8XpcuUnCwT0oFAAAA/BJ7OMEjBE4AAAAA7HT0qLRkiSuAOn48f68vU0bq2dMVQLVqxf5PAAAAQEEQOMEjBE4AAAAAigqn03Q8pYdPS5dKly/n7x7Vq0vXXecKoOrW9U2tAAAAQElF4ASPEDgBAAAAKKpSUqSNG034tGSJtGaNlJycv3s0aeIKn/r0kSpW9E2tAAAAQElB4ASPEDgBAAAAKC7i4qSVK10dUNu35+/1DofUoYMrgOrWTQoN9U2tAAAAQHFF4ASPEDgBAAAAKK5OnTLL7i1eLP34o3ToUP5eX6qU1L27K4Bq104KDPRNrQAAAEBxQeAEjxA4AQAAACgJnE5p/36z9F76EnznzuXvHhUrmv2frr/eBFCNG5uuKAAAAMCfEDjBIwROAAAAAEqitDRp2zZX+LRihZSYmL971K1rgqfrrzdH9eo+KRUAAAAoUgic4BECJwAAAAD+IDFRWrvWtf/Tpk0mlMqP1q1NANWjh3ncsKEUEOCbegEAAAC7EDjBIwROAAAAAPzRhQvSsmWuAGrPnvzfIyxMatlSatXKBFDpP6tXZyk+AAAAFF++yA2CCnwHAAAAAACKoAoVpEGDzCFJR46YpffS94A6cSL3e8THSxs3miOjypWtAVTr1iaYKlfOy28CAAAAKCbocPIDdDgBAAAAgJXTKf3yi6v7afly6fLlgt+3Xj33bqhmzaSQkILfGwAAAPAWOpwAAAAAAPACh8N0JLVsKY0ZIyUnmy6mxYvNMnw7dkhnz+b/vocOmWPBAtdYUJAUGWkNoVq1kho0YH8oAAAAlBx0OPkBOpwAAAAAIH+cTunkSWnXLmnnTtfPn382y+x5Q/r+UJmX5qtWjf2hAAAA4Ft0OAEAAAAAUAgcDqlGDXP07esaT0uTDhywhlC7dkl79kipqfmbI7v9oapUce+GatVKKlu24O8LAAAA8BUCJwAAAAAA8iggQGrUyByDBrnGr1wxoVPmIOrQofzPceaMtHSpOTKqV8/VBZUeRjVtyv5QAAAAKBoInAAAAAAAKKBSpaQ2bcyR0aVLJnjKvDRfQfaH+vZb11hQkAmdMnZDtW4t1a/P/lAAAAAoXAROAAAAAAD4SLlyUteu5kiXvj9U5m4oT/aHSkkxr/v5Z2nGDNd4eLjUrJk5mjZ1PW7SRAoN9c57AwAAADIicAIAAAAAoBBl3B/qhhtc4xn3h8oYRu3dm//9oeLipM2bzZF57gYNXAFUxkCqalVzHgAAAPAEgRMAAAAAAEVATvtD7d7tvizf4cP5n8PplPbvN8d331nPVaxoDaLSjwYNpODgAr01AAAA+AECJwAAAAAAirBSpaS2bc2R0cWLZim99AAq/Th3zrN5zp+X1q41R0ZBQVLjxu5BVNOmUoUKns0FAACAkofACQAAAACAYqh8+az3hzpxwgRRe/aYzqjdu83jI0c8myclxXWfzGrUsO4RlX7UrWs6tgAAAOA/CJwAAAAAACghHA6pZk1z9O1rPRcba/aDSg+P0o+9e82yfZ44ccIcy5dbx0NDTRCVOYyKjJTCwz2bCwAAAEUbgRMAAAAAAH6gTBmpfXtzZJSaKh06ZO2ISj9OnfJsrsREaft2c2RWt651Wb70xzVrmsAMAAAAxROBEwAAAAAAfiwwUGrY0Bz9+1vPnTtngqjMYdS+fSao8sThw+b44QfreNmy1m6oFi2kzp2lWrU8mwcAAACFi8AJAAAAAABkqVIlKSrKHBklJUn791tDqD17pOho6eJFz+a6fFnauNEcGdWpI3XpYo5rrzUdWmFhns0BAAAA3yFwAgAAAAAA+RIS4upEysjpNMvwZV6ab/dus2yf05n/uY4cMcfMmeZ5YKDUpo0Jn9KDqMhIKSCg4O8LAAAAniNwAgAAAAAAXuFwSNWrm6NXL+u5hATp11/dg6g9e6T4+LzPkZoqbd1qjgkTzFiFCmb5vfQAqksXqUoVr70tAAAA5AGBEwAAAAAA8LnSpU1nUps21vG0NCkmxrpP1C+/SFu2SJcu5e3eFy6YPaEy7gvVqJF1Kb62baVSpbz2dgAAAJAJgRMAAAAAALBNQIBUt645brjBNZ6WZsKn9euldevMz507zXhe/PabOb780jwPCZHatbMuxdeggenKAgAAQMEROAEAAAAAgCInIEBq0cIcw4aZsdhYafNmEz6lB1HHjuXtfklJrtelq1rV2gXVqZNUvrz33wsAAIA/IHACAAAAAADFQpkyZm+ojPtDxcRYu6A2bTL7ReXF6dPSt9+aQzLdTs2auQKoLl2kVq2kID49AQAAyBV/ZQIAAAAAAMVWRIQ5Bg82z1NSpF27XAHU+vVSdHTe7uV0mmujo6Vp08xYWJjUsaOrE6pLFzMfAAAArAicAAAAAABAiREUJF1zjTlGjTJjFy5IGzdaO6HOnMnb/eLjpRUrzJGudm3rUnwdOkjh4V5+IwAAAMWMw+l0Ou0uwm6HDh3Se++9pwULFujIkSMqVaqUGjVqpLvuukuPP/64wsLCPL53dHS0lixZoo0bN2rnzp06deqUzpw5o8DAQFWvXl2dOnXSvffeq4EDB8rho51KY2JiVKdOHUnSkSNHFMFXsQAAAAAAfszplA4csHZBbd1q9nnyRGCgWXov41J8zZqZfagAAACKIl/kBn4fOM2fP1/33XefLl26lOX5yMhILViwQI0bN/bo/vfdd5+++OKLXK/r1auXZs2apcqVK3s0T04InAAAAAAAyNmVK9K2ba4Aat06af9+z+9XrpzUsqXUuLHraNTI/KxUyewXBQAAYBcCJy/bunWrunXrpoSEBJUpU0bPPfec+vTpo4SEBE2fPl2TJk2SZEKnTZs2qWzZsvme46GHHtLu3bvVrVs3tW7dWjVq1FDVqlV1/vx57d69Wx999JF27dolSYqKitKqVasU4OWvQBE4AQAAAACQf6dPSxs2uDqhNmyQLl4s+H0rVHAPodKP6tUJowAAgO8ROHlZz549tXLlSgUFBWnFihWKioqynH/rrbc0duxYSdJLL72kl19+Od9zpKSkKCgo+62yUlNTddddd2n27NmSpLlz52rgwIH5nicnBE4AAAAAABRcWpq0d691Kb4dO6TUVO/NER7uHkKlB1MRESzTBwAAvIPAyYs2bNigLl26SJIeffRRTZw40e2atLQ0tWrVStHR0apQoYJOnTql4OBgr9eybt26q2HXs88+q7feesur9ydwAgAAAADAN+Ljpc2bXcvwrV8vxcT4Zq5SpaSGDbPujqpXT8rh+64AAAAWvsgN/PavInPmzLn6eNiwYVleExAQoAceeEDPPfecLly4oKVLl6pfv35eryXjUn2JiYlevz8AAAAAAPCNsDCpRw9zpDt2TNqyRfrtN2nfPtdx4EDBuqGuXJGio82RWVCQVL9+1t1RDRqYsAoAAMCX/DZwWrVqlSQpPDxcHTp0yPa6Xr16XX28evVqnwRO06dPv/q4WbNmXr8/AAAAAAAoPLVqmSOz5GTp8GH3IGrfPmn/fhMoeSolxXWv77+3nnM4pDp13JfoS/8ZHu75vAAAAOn8NnCK/v3rQI0bN85xj6WMAVB0Vl8h8tCZM2f066+/6pNPPtHUqVMlSVWqVNEf/vCHfN8rJpde/ePHj3tUIwAAAAAA8J7gYBPwNGokZf4+a1qadPSoNYTKGEzFxXk+r9Npgq7Dh6WffnI/X7Nm1p1R9etLFSpIgYGezw0AAPyHXwZOiYmJOnPmjCTlui5hxYoVFR4erri4OB05cqRA8/bu3VvLly/P8lyVKlX0zTffqEKFCvm+b/o6iwAAAAAAoHgKCDBdSHXqSH36WM85ndLJk+4hVPpx4ULB5j5+3By/LwZj4XBI5cpJFStKlSqZn9kdmc+XL2/eFwAA8A9+GThdvnz56uMyZcrken164BQbG+uTev70pz/phRdeUJUqVXxyfwAAAAAAUHw5HFKNGubo3t39/Llz7iFUejB16lTB5nY6pYsXzXHwYP7rLl8++0Aqp8CqXDnCKgAAihu/DJwSExOvPg4JCcn1+lK/76yZkJBQoHmnTp2quLg4OZ1OXbhwQZs2bdKECRP0wQcfaP/+/frkk09UvXr1fN83t86r48ePq3Pnzp6WDQAAAAAAirBKlaTOnc2R2aVLrvApc3fU0aO+rcvpNN1XFy5IBw7k77UBAQULqxwOX7wjAACQE78MnEJDQ68+TkpKyvX6K7/v2lm6dOkCzdugQQPL8x49emj06NEaMmSIvv32W3Xq1Elr1qzJdZm/zPJ7PQAAAAAA8A/lyknt2pkjs/h4af9+9yDqt9+kQ4fMvlJ2SUuTzp83R34FBJi9pypWlOrWlVq2lFq0MEfLlhILzAAA4Bt+GTiVLVv26uO8LJMX9/vOnHlZfi+/QkNDNXXqVNWrV09HjhzR2LFj9eWXX3p9HgAAAAAAgIzCwqRWrcyRWVKSWY7v/HmzZF96+JPVkfl8Skrhv5eM0tJMTefOmfBs6VLr+apV3UOoFi3MOJ1RAAB4zi8Dp9DQUFWuXFlnz55VTExMjteeP3/+auBUp04dn9RTpUoVdevWTT/++KPmzp2r5ORkBQcH+2QuAAAAAACA3ISESBER5sgPp1OKi8s+jMotrEpN9c37yej0aWnZMnNkVLly1kFU9eoEUQAA5IVfBk6S1KJFC61cuVL79u1TSkqKgoKy/qPYvXv31cfNmzf3WT1Vq1aVJMXHx+vMmTOqWbOmz+YCAAAAAOD/27v3KC3Len/874HhjIgKCAgKykY0EU1F8RihdlDzlJpl4ilLs3Ln3ju17+q4d5ktU5fLbZ7JvXNrklaI7dS2Th4wIqUsz4IkDCKgAsJwGHh+fzy/eRicA4dnhgHm9VrrWnPPfd2Hz+Nat9cw77muG1pDRUXSs2exbezf7RYKyfvvb1pY9d575YdVCxcmf/hDsdW3ww6NB1EDBgiiAKC+dhs4HX744XniiSeydOnS/PnPf87BBx/c6HFVVVWl7cMOO6zV6plT702drbF0HwAAAMCWrKIi2W67Ytt11407t1BIlixZN5CaPz955ZXk739PXngheeml4lKBG+vdd5Mnnyy2+nr3bhhC7b13sssugigA2qd2GziddNJJ+eEPf5gkufPOOxsNnNasWZO77rorSdK7d++MHTu2VWqZPXt2pkyZkiTZbbfd1nnHFAAAAADNq6hIevUqtt12a/yY2tpkxoxi+PTCC+sGUcuXb/w933svefrpYquvV6+GQdSHPlRcnlAQBcC2rN0GTqNHj84RRxyRJ554IrfffnvGjx+fMWPGrHPMNddckxdffDFJ8rWvfa3Be5Uef/zxUgg1fvz4TJgwYZ3+V155JbNnz85HP/rRJutYtGhRPvvZz2bl//8nNmeffXa5Hw0AAACAD6isTIYPL7aTTlq7f/XqZObMhkHUiy8mNTUbf5/Fi5Nnnim2+nr2bDgb6kMfKi492KFDWR8NALYI7TZwSpLrr78+hx12WGpqanLsscfmyiuvzNixY1NTU5N77rknt9xyS5Jk+PDhueyyyzb6+tXV1Rk3blxGjRqVk046KQcccED69++fysrKvPXWW3nqqady++2356233kqS7LPPPrn88stb9DMCAAAA0LSOHZNhw4rtU59au3/16mTWrHVDqLq2bNnG3+f995OpU4utvh49kr32Wnc21N57F2dqCaIA2Jq068Bp//33z7333puzzjorixcvzpVXXtngmOHDh2fy5MllLXP3l7/8JX/5y1+aPea4447LnXfeme7du2/yfQAAAABoGR07JrvvXmzHH792/5o1yT/+0XgQ9f77G3+fpUuTadOKrb7u3ZMRI4pB2B57FOuo+zpoULE+ANiStOvAKUlOOOGE/PWvf83111+fyZMnZ/bs2encuXOGDRuW0047LZdccskmh0CHHXZYfve73+XRRx/NtGnTMnv27MybNy/Lli1Lr169MnTo0BxyyCE588wzc9hhh7XwJwMAAACgpXXokAwZUmyf/OTa/YVC8uabDYOov/89WbJk4++zbFny7LPF9kGdOhXv/8Egao89kqFDi8v3AcDmVlEoFAptXQSta/bs2Rk8eHCS5M0338ygQYPauCIAAACA9qFQSObMaRhCvfBCsmhR69xz550bBlF1X/v3TyoqWue+AGw9WiM3aPcznAAAAACgtVRUFJfAGzQo+djH1u4vFJK5cxsGUX//e/Lee+Xdc968YpsypWFft25rlwr8YCA1dGjSpUt59wag/RI4AQAAAMBmVlGRDBxYbMccs3Z/oVAMi/7+9+Tll5MZM4rt9deLbenS8u5bU7M22Gqspl12aXxm1O67JzvtZHYUAE0TOAEAAADAFqKiorjsXf/+ybhx6/YVCsn8+WsDqA9+ra4u796FQjJ7drFVVTXs79Wr6aX6dt01qfSbRoB2zTAAAAAAAFuBioqkX79iO+SQhv01NcnMmY0HUjNmJCtWlHf/xYuT6dOL7YM6dkx2261hELXbbsmAAcWaO3Uq7/4AbNkETgAAAACwDejWLdl772L7oDVriu+Mamxm1IwZxZlT5Vi9em2w9eijDfsrKpI+fYoztwYMaP7rdttZug9gayRwAgAAAIBtXIcOxfcz7bJLcuSRDfsXLy7OjmoskJo1K6mtLe/+dcsBzp+fPP9888d2775hwVS/fsWZVQBsGQROAAAAANDO9eqVjBpVbB9UW1t8r1NjYdTrryeLFrVsLcuWrZ0t1ZwOHZK+fdcNopoKp3r0aNkaAWhI4AQAAAAANKmyMhkypNjGjWvY/847jS/T9/rrSXV1+bOjmrJmTTJvXrGtz3bbbdisqT59ikEWABtP4AQAAAAAbLIddyy2Aw9s2LdmTTGQeuut4jukmvo6d25xWb/WsmRJsb36avPHdeyY7LzzukHUiBHJ/vsn++1X/JwANE7gBAAAAAC0ig4dirOG+vRJ9tmn+WOXLSsGUOsLp+bNKwZZrWH16uKsrOrqxvt3260YPO2//9o2aFBSUdE69QBsTQROAAAAAECb69492X33YmvO6tXJggUbNmtq6dKWrXHWrGL79a/X7ttpp7UhVN3XPfcszpYCaE8ETgAAAADAVqNu2budd05GjWr+2Pffbz6Uqvs6f35SKGxaPQsXJr//fbHV6dYtGTly3ZlQI0cW9wNsqwROAAAAAMA2qWfP5J/+qdiaU1ubvP12wyDqjTeS6dOT559PVq7c8PvW1CRTpxZbnQ4d1n0fVF0Q5b1QwLZC4AQAAAAAtGuVlcnAgcXWmFWrkpdeSp57rtimTy9+XbRow++xZk3ywgvF9vOfr92/667rBlD77Vfc571QwNZG4AQAAAAA0IxOnYpL4o0cmZx9dnFfoVCcAVU/gHruuWTOnI279j/+UWy/+c3afTvu2Ph7oSr9NhfYgvlfFAAAAADARqqoSIYOLbZTTlm7f/78dQOo6dOTl1/euHdEvfNO8n//V2x1unZN9t133dlQI0cm3bu30AcCKJPACQAAAACghfTtmxxzTLHVWbo0+etf1w2inn8+WbFiw6+7fHnj74Xac8+G74XaaaeW+jQAG07gBAAAAADQinr0SMaMKbY6q1YVZz7VBVB1s6Hee2/Dr7tmTfLii8V2991r9w8evDaAGjGieP+uXYutW7e12x/83pJ9QDn8LwQAAAAAYDPr1CnZZ59i+/zni/sKhWTWrIbvhZo9e+Ou/eabxTZp0sad17Fj84FUud8Lu2Db5jEGAAAAANgCVFQkQ4YU28knr92/YMG6AdRzz238e6E2xOrVyfvvF9vm1lzY1atXsuOOyQ47FFtj23Vft9uu+N8R2PwETgAAAAAAW7A+fZKjjy62OkuXFt8DVX821PPPF9/1tDVqqbCrY8e1YVRjgVRzgVW3bi3zWaC9EjgBAAAAAGxlevRIDjmk2OrU1iYvvbQ2gJo+PZk7txhC1W81NW1Vdetbvbo4I2zBgo0/t0uX9c+gamq7U6eW/yywtRE4AQAAAABsAyor174X6qyzmj6uUEhWrmwYQrXk980d09JLAbaUFSuSt94qto3Vs2fTgdROOyW77ZYMHVpcLnHnnS37x7ZJ4AQAAAAA0I5UVBRn83Tpkmy//ea9d6GQrFq14SFWTU2yaFHyzjvJu++u/frB7dWrN+/n+KC65QDffHP9x3brtvZdXUOHrg2i6rZ32EEgxdZJ4AQAAAAAwGZRUZF07lxsvXq1zDULhWTJknVDqOYCqvr7Fi1qmRo2Rk1N8uKLxdaYXr2aDqOGDi3OpoItkcAJAAAAAICtVkVFMaTp1au4dN3GqK1ddwbVxoRVy5a1zudZvDj561+LrTE77dR0GLXbbknXrq1TF6yPwAkAAAAAgHapsrIY4Oy008afu2LFhgVTc+cmb7yR/OMfxeUEy7VwYbFNm9Z4/4ABDcOouu3Bg5NOncqvARojcAIAAAAAgI3UpUvSv3+xbYjVq5Pq6mTmzGJ74411t2fPTtasKb+uuXOL7emnG/Z16FAMnZpasm/gwOIxsCkETgAAAAAA0Mo6diyGPYMHJ0ce2bB/5crkzTcbBlF122+9VX4Na9Yks2YVW1VVw/5OnYrL8n0wjNp117XhWvfu5dfBtkngBAAAAAAAbaxz52SPPYqtMTU1xaCosdlRM2cWl9kr16pVyWuvFVtTevUqBk8DBjT+tW57p53MlmpvBE4AAAAAALCF69YtGTGi2BqzeHExfGpqhtSSJS1Tx+LFxfbKK80fV1mZ7Lxz42HUB/d169YytdG2BE4AAAAAALCV69Ur2XffYvugQiF5992m3x/1xhvFGVQtqbY2mTOn2NZn++2bD6Xqvu64o1lTWzKBEwAAAAAAbMMqKophzY47Jgcc0LC/UEjmzWt6dlR1dcsHUvUtWlRsL73U/HGdOjWcNdVYUNW/f9K1a+vVS+METgAAAAAA0I5VVKwNag45pGF/oVBcku+tt5K5c4tf62/X/7pgQfH41rBqVTJ7drGtT+/eDcOo0aOTM85ondoQOAEAAAAAAM2oqCgu2derVzJ8ePPHrlqVzJ/feBhVP6iaOzdZvrz1an7vvWJ78cW1+844Q+DUmgROAAAAAABAi+jUKRk4sNiaUygkixc3P1uqrm/+/JaprX//lrkOjRM4AQAAAAAAm1VFRbL99sW2557NH7tqVfL2203Plqo/a2rFiqavM2BAy34G1iVwAgAAAAAAtlidOiW77FJszambNdXUbKkPf3jz1NteCZwAAAAAAICtXv1ZUyNGtHU17U+Hti4AAAAAAACArZvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKEtlWxdA66utrS1tz507tw0rAQAAAAAA2lr9rKB+hlAOgVM7MH/+/NL26NGj27ASAAAAAABgSzJ//vwMGTKk7OtYUg8AAAAAAICyVBQKhUJbF0HrWr58eZ5//vkkSd++fVNZaWJbUpwyWDfja+rUqRkwYEAbVwRsCs8ybBs8y7Bt8CzDtsGzDNsGzzJsG1rrWa6trS2tjjZy5Mh07dq17GtKHtqBrl275qCDDmrrMrZoAwYMyKBBg9q6DKBMnmXYNniWYdvgWYZtg2cZtg2eZdg2tPSz3BLL6NVnST0AAAAAAADKInACAAAAAACgLAInAAAAAAAAyiJwAgAAAAAAoCwCJwAAAAAAAMoicAIAAAAAAKAsAicAAAAAAADKUlEoFAptXQQAAAAAAABbLzOcAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJxol2bNmpXLLrssI0aMSI8ePbLjjjvmoIMOyo9//OMsW7asrcsD1qOiomKD2kc+8pG2LhXarbfffjsPPvhgvvWtb+UTn/hE+vTpU3o2zznnnI2+3m9/+9ucfPLJGTRoULp06ZJBgwbl5JNPzm9/+9uWLx4oaYlnecKECRs8dk+YMKFVPw+0R9OmTcv3vve9HHvssaVxtGfPnhk+fHjOPffcPPnkkxt1PWMytI2WeJaNydC2Fi9enHvuuSeXXXZZjjrqqAwbNizbb799OnfunH79+uUjH/lIrr766ixcuHCDrvf000/nrLPOym677ZauXbumf//++djHPpb/+Z//aeVP0rTKNrsztJFJkyblrLPOyuLFi0v7li1blmnTpmXatGm57bbbMnny5AwbNqwNqwSArdvOO+/cItdZs2ZNLrzwwtx+++3r7J8zZ07mzJmTX/3qV7ngggty8803p0MHf0sFLa2lnmWgbRx55JF54oknGuxfuXJlXn311bz66quZMGFCzj777Nx6663p3Llzk9cyJkPbaclnGWg7U6dOzZlnntlo3/z581NVVZWqqqr8+Mc/zn//93/nYx/7WJPX+s53vpPvf//7WbNmTWnfvHnz8vDDD+fhhx/Oz3/+80ycODFdu3Zt8c/RHIET7cpzzz2XM844IzU1NenZs2euuOKKjB07NjU1Nbnnnnty66235pVXXslxxx2XadOmZbvttmvrkoFmXHTRRbn44oub7O/Ro8dmrAZoyq677poRI0bk4Ycf3uhzv/nNb5Z+sbX//vvn3/7t37LHHnvk9ddfz9VXX53nnnsut912W/r27Zsf/OAHLV06UE85z3Kd3/3udxk4cGCT/YMGDdrkawMNVVdXJ0kGDhyY0047LUcccUR23XXXrF69OlOmTMk111yTOXPm5K677sqqVaty9913N3ktYzK0nZZ8lusYk6FtDB48OGPHjs0BBxyQwYMHZ8CAAVmzZk1mz56diRMn5v7778+CBQvyqU99KlOnTs2oUaMaXOPmm2/Od7/73STJHnvskSuvvDIjR45MdXV1rr/++jz22GOZPHlyzjvvvA36/0GLKkA7csQRRxSSFCorKwtPP/10g/6rr766kKSQpPDtb3978xcIbBDPKWz5vvWtbxUmTZpUeOuttwqFQqEwc+bM0rM7fvz4DbrGyy+/XKisrCwkKRx44IGFZcuWrdO/dOnSwoEHHlga21999dWW/hjQ7rXEs3znnXeWzpk5c2brFQs0cNxxxxXuvffeQm1tbaP98+fPLwwfPrz0jFZVVTV6nDEZ2lZLPcvGZGhbTT3D9T3wwAOl5/Tkk09u0L9w4cLC9ttvX0hS2HXXXQvz589vcI8TTjihdI3HHnuspcrfIOY4025MnTq1NP34/PPPz5gxYxocc9lll2WvvfZKklx//fVZtWrVZq0RALYV3/3ud3P88ceXtRzXddddl9ra2iTJDTfckG7duq3T371799xwww1Jktra2lx77bWbXjDQqJZ4loG28+CDD+b0009Px44dG+3v06dPrrnmmtL3EydObPQ4YzK0rZZ6loG21dQzXN9JJ52UPffcM0kaXUrztttuy6JFi5IkP/rRj9KnT58G9/jP//zP0r1+/OMfl1v2RhE40W786le/Km2fe+65jR7ToUOHnH322UmS9957L4899tjmKA0A+IBCoZBf//rXSZIRI0bkkEMOafS4Qw45pPTD+K9//esUCoXNViMAbAvGjh1b2n799dcb9BuTYeuwvmcZ2HrUveZl+fLlDfrqfsfdq1evnHLKKY2eP2jQoBx99NFJkt///vdZsmRJ6xTaCIET7caTTz6ZpPhOlwMOOKDJ44466qjS9lNPPdXqdQEADc2cObO0Vn39sbkxdf1z5szJG2+80dqlAcA2ZcWKFaXtxv7y2pgMW4f1PcvA1uHll1/O9OnTkxT/0KO+lStXZurUqUmSMWPGpHPnzk1ep25MXrFiRaZNm9Y6xTZC4ES78eKLLyZJhg0blsrKyiaPq/8g150DbJnuu+++7L333unevXu22267/NM//VPGjx9vdiJsA1544YXS9gd/yP4gYzdsPc4999wMHDgwnTt3Tp8+fXLIIYfk//2//5c5c+a0dWnQblVVVZW265aYr8+YDFuH9T3LH2RMhi3HsmXL8uqrr+YnP/lJjjrqqNIytpdeeuk6x73yyitZvXp1ki13TBY40S4sX748CxYsSFKcUticHXbYIT169EiSvPnmm61eG7DpXnjhhbz44oupqanJ+++/n9deey133XVXPvrRj+bkk08urWkLbH1mz55d2l7f2D148ODStrEbtmyPP/545s6dm1WrVmXhwoX54x//mP/4j//IsGHDcvPNN7d1edDurFmzJldddVXp+9NPP73BMcZk2PJtyLP8QcZkaFsTJkxIRUVFKioq0qNHjwwfPjyXXXZZ5s2blyS5/PLL89nPfnadc7aGMbnpaR6wDam/TmXPnj3Xe3yPHj2ydOnSvP/++61ZFrCJunfvnk996lMZN25cRowYkZ49e2b+/PmpqqrKT3/60yxcuDC/+tWvcuKJJ+aRRx5Jp06d2rpkYCNtzNhd94ciSYzdsIXafffdc8opp2TMmDGlf/zOmDEjv/zlLzNx4sQsX748X/rSl1JRUZELL7ywjauF9uPaa68tLc1zyimnNLr8vDEZtnwb8izXMSbDlm2//fbLLbfckoMOOqhB39YwJgucaBfqv2CtubUt63Tp0iVJUlNT02o1AZtuzpw56d27d4P9xxxzTL7yla/kE5/4RJ577rlUVVXlpptuyle/+tXNXyRQlo0Zu+vG7cTYDVuik08+OePHj09FRcU6+w866KCcccYZefDBB3PKKadk1apV+ed//ud86lOfSv/+/duoWmg/qqqqcvnllydJ+vXrl5tuuqnR44zJsGXb0Gc5MSbDluSkk07KgQcemKQ4Zr7++uv5xS9+kQceeCBnnnlmrrvuuhx//PHrnLM1jMmW1KNd6Nq1a2l75cqV6z2+7kWL3bp1a7WagE3XWNhUZ+edd87EiRNLs5puuOGGzVQV0JI2Zuyu/4JkYzdsebbffvsGv9iq2KTBbwAAEyNJREFU7/jjj8+3vvWtJMX162+//fbNVRq0W3//+99z8sknp7a2Nl27ds19992Xfv36NXqsMRm2XBvzLCfGZNiS9O7dO/vss0/22WefHHTQQfnMZz6T+++/P3fddVdmzJiRE088MRMmTFjnnK1hTBY40S5st912pe0NmUK4dOnSJBu2/B6w5dl9991zzDHHJElee+21VFdXt3FFwMbamLG7btxOjN2wtbrwwgtLvwCr/9JzoOXNnDkzxx57bN5999107Ngx99xzT4488sgmjzcmw5ZpY5/lDWVMhrb1+c9/PqeddlrWrFmTSy65JO+8806pb2sYkwVOtAtdu3bNTjvtlGTdl6s15t133y09kPVfrgZsXfbee+/S9pw5c9qwEmBT1H8B6vrG7vovQDV2w9apX79+pZ/XjdvQeqqrq3P00Uenuro6FRUVueOOO3LiiSc2e44xGbY8m/IsbyhjMrS9uud56dKl+d///d/S/q1hTBY40W7U/fL5tddeS21tbZPHvfTSS6Xtvfbaq9XrAlpHc8sEAFu++qFx/bG5McZu2DYYu6F1LViwIMccc0xmzJiRpLj09Nlnn73e84zJsGXZ1Gd5YxiToW317du3tD1r1qzS9vDhw9OxY8ckW+6YLHCi3Tj88MOTFJPhP//5z00eV3+68GGHHdbqdQGt44UXXihtDxw4sA0rATbF0KFDS8/u+pby+MMf/pAk2WWXXTJkyJDWLg1oBfPnz8+CBQuSGLehNSxatCgf+9jHSj8jX3XVVfnyl7+8Qecak2HLUc6zvKGMydD26s8urL8cXufOnTN69OgkyZQpU5p9j1PdmN2lS5cceOCBrVRpQwIn2o2TTjqptH3nnXc2esyaNWty1113JSm+uG3s2LGbozSghc2cOTOPPPJIkmSPPfbILrvs0sYVARuroqKitIzASy+9lGeeeabR45555pnSX26deOKJ/hoTtlK33HJLCoVCkuSoo45q42pg27Js2bIcd9xxefbZZ5Mk3/zmN/ONb3xjg883JsOWodxneUMZk6Ht3XfffaXtkSNHrtNX9zvuxYsX5/7772/0/NmzZ+fRRx9NkowbN26ddz+1NoET7cbo0aNzxBFHJEluv/32TJkypcEx11xzTV588cUkyde+9rV06tRps9YIrN+kSZOaXRZz3rx5OfXUU0t/5XHxxRdvrtKAFnbppZeWlgv4yle+kpqamnX6a2pq8pWvfCVJUllZmUsvvXRzlwisxxtvvJHnnnuu2WMefPDBfO9730uSdOvWLeeee+7mKA3ahZUrV+bkk0/OU089laT479x///d/3+jrGJOhbbXEs2xMhrY3YcKELF++vNljrr322jz00ENJirOM636fXeeCCy7I9ttvnyS5/PLLs3DhwnX6V69enYsvvjirV69Okvzrv/5rS5W/QSoKdZE1tAPPPfdcDjvssNTU1KRnz5658sorM3bs2NTU1OSee+7JLbfckqS4Hua0adM2a/oLbJghQ4Zk1apVOfXUUzNmzJgMGTIk3bp1y4IFC/L444/n5ptvLk3/P/zww/Poo4+mS5cubVw1tD9PPvlkXnvttdL3CxYsKP2ge9hhh+WCCy5Y5/hzzjmn0etcccUVueqqq5Ik+++/f77xjW9kjz32yOuvv54f/ehHpX80X3HFFfnBD37QCp8E2rdyn+XHH388Y8eOzZgxY3LCCSdk1KhR6devX5JkxowZmThxYiZOnFj6S+obb7zRH4tACzr11FNLf/380Y9+NNddd12zM486d+6c4cOHN9pnTIa20xLPsjEZ2t6QIUOyZMmSnHrqqTn88MOzxx57pGfPnlmyZEmef/75/PznPy8Fy507d87kyZNz9NFHN7jOzTffnC996UtJiiv7fPOb38zIkSNTXV2d6667Lo899liS5Mwzz8zdd9+9+T5gBE60Q5MmTcpZZ52VxYsXN9o/fPjwTJ48OcOGDdvMlQEbYsiQIeu8MLEpp556am677bb07t279YsCGjjnnHPys5/9bIOPb+pH0jVr1uQLX/hC7rjjjibPPf/883PLLbekQweT96Gllfss1/1ya326d++ea6+9NhdeeOFG1wg0bWOXtdttt93yxhtvNNpnTIa20xLPsjEZ2t6G/k5r0KBBueOOO3LMMcc0ecy3v/3tfP/732/y39Kf/OQn88tf/jJdu3bd5Ho3hcCJdmnWrFm5/vrrM3ny5MyePTudO3fOsGHDctppp+WSSy5J9+7d27pEoAlVVVWpqqrKlClTMmPGjCxYsCCLFy9Oz549M3jw4Bx66KEZP358xowZ09alQrvWUoFTnYceeii33HJL/vSnP2XBggXp06dPDjrooHzxi1/MJz7xiXLLBZpQ7rO8ZMmS/OY3v8mUKVMybdq0zJ07NwsWLEhtbW122GGHfOhDH8q4ceNywQUXlP7KGmg5LRk41TEmw+bXEs+yMRna3ssvv5zJkyfnqaeeymuvvZZ58+Zl4cKF6datW/r165f99tsvxx9/fE4//fQN+v30008/nRtvvDFPPPFE5s2bl969e2fUqFE599xzc+aZZ26GT9SQwAkAAAAAAICymOMMAAAAAABAWQROAAAAAAAAlEXgBAAAAAAAQFkETgAAAAAAAJRF4AQAAAAAAEBZBE4AAAAAAACUReAEAAAAAABAWQROAAAAAAAAlEXgBAAAAAAAQFkETgAAAAAAAJRF4AQAAAAAAEBZBE4AAAAAAACUReAEAAAAAABAWQROAAAAAAAAlEXgBAAAAAAAQFkETgAAAAAAAJRF4AQAAAAAAEBZBE4AAABssjfeeCMVFRWpqKjIhAkT2rocAACgjQicAAAANsHjjz9eClo2tF166aVtXTYAAECrEDgBAAAAAABQlsq2LgAAAGBrd9FFF+Xiiy9e73F9+vTZDNUAAABsfgInAACAMvXr1y/77LNPW5cBAADQZiypBwAAAAAAQFkETgAAAG1kyJAhqaioyDnnnJMk+dOf/pQzzzwzgwcPTteuXTN48OCce+65eemllzboepMmTcqnP/3pDBo0KF26dMlOO+2UMWPG5Kqrrsr777+/Qdf429/+lq985SsZOXJkdthhh3Tq1Cn9+/fP0Ucfnauvvjpz585d7zUeeeSRnHDCCenfv3+6dOmSoUOH5qKLLsrs2bObPa+6ujqXX355PvzhD2f77bdPp06dsvPOO2fkyJE588wzM2HChCxevHiDPgcAALB5VRQKhUJbFwEAALC1efzxxzN27Ngkybe//e185zvf2ehrDBkyJLNmzcr48eNz5JFH5otf/GJqa2sbHNelS5f813/9V0477bRGr7N8+fJ89rOfzQMPPNDkvQYOHJjJkydnv/32a7R/9erV+dd//ddcd911ae6fiePHj8+ECRNK37/xxhsZOnRokuTOO+/Myy+/nKuuuqrRc/v27ZuqqqrstddeDfqeeOKJHH/88esNlCZNmpTjjz++2WMAAIDNzzucAAAA2tj06dNz9913p1+/frniiisyevToLF++PA899FCuu+66rFixIp/73OcydOjQHHjggQ3OHz9+fClsGjVqVC677LLstddeeeedd3LPPfdkwoQJqa6uzrhx4/LXv/41u+yyS4NrXHjhhbnjjjuSJAMGDMgll1ySQw89NNtvv33mz5+fqVOnZuLEic1+jltvvTVPP/10jjrqqHzxi1/M8OHD89577+Wuu+7KXXfdlfnz5+e8887LlClT1jlvxYoV+cxnPpPFixdnu+22y0UXXZSxY8emX79+WblyZWbOnJmnn3662UANAABoW2Y4AQAAbIL6M5wuuuiiXHzxxes9Z88990ynTp1K39fNcEqS3XbbLc8880z69++/zjmPPfZYjj322NTW1uaggw7K1KlT1+mfPHlyacbPuHHj8tBDD6Vz587rHHPrrbfmwgsvTJKcfvrpuffee9fp/81vfpMTTzwxSTJmzJg89NBD6d27d6Of4c0338zgwYNL39ef4ZQkX/jCF3LzzTenoqJinfO+8IUv5LbbbkuSPPvss9l///1Lff/3f/+XcePGJWl+BlNtbW2WLVuWXr16NdoPAAC0HYETAADAJqgfOG2omTNnZsiQIaXv6wdOEydOzKmnntroeRdffHFuuummJMX3PNWf5fTJT34yv/3tb9OpU6e8/vrr64RB9R1zzDF59NFHU1lZmX/84x8ZMGBAqe/QQw/NlClT0r1797z66qsZOHDgBn+m+oHTgAEDMnPmzHTp0qXBcS+//HJGjBiRJLn++uvz1a9+tdR3991353Of+1ySZNGiRQIlAADYCnVo6wIAAADaux122KE0w6gx5513Xmn70UcfLW3X1tamqqoqSXLsscc2GTYlxRlGdec8/vjjpf0LFy7MM888kyQ544wzNips+qBPf/rTjYZNSXF2V8+ePZMkM2bMWKevfvh15513bvL9AQCAtiNwAgAAKNO3v/3tFAqF9bb6s5vq23///VNZ2fQrdvfbb7/SMnnPP/98af+MGTOybNmyJMnBBx/cbI31+//2t7+VtqdPn566hS+OOOKI5j/oetTNYGrKDjvskCRZsmTJOvsPP/zw7L777kmSSy+9NKNHj84Pf/jDPPXUU1m5cmVZNQEAAJuHwAkAAKCN9evXr9n+ysrK7LjjjkmSd955p7S//vb6rlH/3VD1z1uwYEFpu/5Mo03RvXv3Zvs7dCj+E3T16tXr7O/UqVMmTZqUvfbaK0lx2cArr7wyhx9+eHr37p2Pf/zjufvuuxucBwAAbDkETgAAAG2soqJii7hGW9p7773z/PPP54EHHsh5552XYcOGJUlqamryu9/9Lp/73Ody8MEH5+23327jSgEAgMYInAAAANrYvHnzmu2vra0tzUqqm+n0we31XeOtt95q9Lw+ffqUtufOnbthBbeSjh075qSTTsrtt9+eV199NdXV1bnjjjtywAEHJEn+/Oc/54tf/GKb1ggAADRO4AQAANDGpk+fntra2ib7//KXv5TeZbTPPvuU9u++++6lZez++Mc/NnuPqVOnlrbrX2P//fcvzY76wx/+sPHFt6IBAwbk3HPPzZQpU/LhD384SfLggw+mpqamjSsDAAA+SOAEAADQxt55551MmjSpyf477rijtH300UeXtisrK3PUUUclSR555JHMnj27yWvcdtttpXM+8pGPlPbvuOOOOfTQQ5Mkv/jFL1JdXb1Jn6E1derUqfQ5a2tr895777VtQQAAQAMCJwAAgC3A17/+9UaXxauqqsott9ySJDnggANy0EEHrdP/5S9/OUmycuXKnH/++Vm1alWDa9xxxx15+OGHkySnnHJKBgwYsE7/N77xjSTJsmXLctppp2XRokVN1tlcqLWpnnjiibz22mtN9q9cuTJVVVVJkp49e6Zv374tXgMAAFCeyrYuAAAAYGv39ttv529/+9t6j+vWrVv22GOPBvtHjRqVF154IQcccECuuOKKjB49OitWrMhDDz2Ua6+9NrW1tamsrMyNN97Y4Nzjjjsup512Wu677748/PDDOeSQQ/L1r389I0aMyLvvvpt77rmnNENqxx13zE9+8pMG1zjhhBNy/vnn5/bbb8/TTz+dvffeO5dcckkOO+yw9OrVKwsWLMi0adNy7733ZtSoUZkwYcLG/0dqxu9///t8//vfzxFHHJHjjjsu++67b/r27Zuampq88sor+elPf5pnn302SXL++eenstI/ZQEAYEvjp3QAAIAy3XTTTbnpppvWe9yoUaMyffr0Bvv322+/XHLJJbnoootyySWXNOjv3Llzfvazn+Xggw9u9Lp33XVXamtr88ADD+TZZ5/NWWed1eCYgQMHZvLkydlll10avcbNN9+cbt265cYbb0x1dXWuvPLKJj9Da1izZk2qqqpKM5kac+KJJ+aHP/xhq9wfAAAoj8AJAABgC3DBBRdkn332ybXXXpsnn3wyCxYsSN++fTNu3Lh84xvfyN57793kuV27ds3999+fSZMmZcKECXnmmWeyYMGC9OjRI8OHD89JJ52USy65JD179mzyGh07dswNN9yQc889NzfffHMef/zxzJkzJytXrsxOO+2UfffdNx//+Mfz+c9/vsU/+7/8y79k3333zaOPPprnnnsu1dXVefvtt5Mk/fv3z+jRo3P22WfnuOOOa/F7AwAALaOiUCgU2roIAACA9mjIkCGZNWtWxo8f3+LL1AEAAGxOHdq6AAAAAAAAALZuAicAAAAAAADKInACAAAAAACgLAInAAAAAAAAyiJwAgAAAAAAoCwVhUKh0NZFAAAAAAAAsPUywwkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACiLwAkAAAAAAICyCJwAAAAAAAAoi8AJAAAAAACAsgicAAAAAAAAKIvACQAAAAAAgLIInAAAAAAAACjL/wdvOY/MjiELDgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 602,
       "width": 846
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%config InlineBackend.figure_format='retina'\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(train_loss_list, color=\"blue\", linestyle=\"-\", label=\"train loss\")\n",
    "plt.plot(valid_loss_list, color=\"red\", linestyle=\"-\", label=\"valid loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 模型评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def equation_accuracy(preds, tgts):\n",
    "    correct = 0\n",
    "    for tgt, pred in zip(tgts, preds):\n",
    "        if tgt == pred:\n",
    "            correct += 1\n",
    "    return correct / len(tgts)\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def greedy_decode(model, src, max_len, start_symbol):\n",
    "    src = src.to(DEVICE)\n",
    "    ys = torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(DEVICE)\n",
    "    src_mask, tgt_mask, src_padding_mask, _ = create_mask(src, ys)\n",
    "\n",
    "    memory = model.encode(src, src_mask, src_padding_mask)\n",
    "\n",
    "    for i in range(max_len - 1):\n",
    "        tgt_mask = torch.ones((ys.shape[1], ys.shape[1]), dtype=torch.bool, device=DEVICE).triu_(diagonal=1)\n",
    "\n",
    "        out = model.decode(ys, memory, tgt_mask)\n",
    "\n",
    "        prob = model.generator(out[:, -1])\n",
    "        _, next_word = torch.max(prob, dim=1)\n",
    "        next_word = next_word.item()\n",
    "\n",
    "        ys = torch.cat([ys, torch.ones(1, 1).fill_(next_word).type(torch.long).to(DEVICE)], dim=1)\n",
    "        if next_word == tgt_vocab[\"<eos>\"]:\n",
    "            break\n",
    "    return ys\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def inference(model, problem):\n",
    "    model.eval()\n",
    "    src = preprocess_src_sentence(problem, src_tokenizer, 120)\n",
    "    src = src.unsqueeze(0)\n",
    "    tgt_tokens = greedy_decode(model, src, max_len=50, start_symbol=tgt_vocab[\"<bos>\"]).flatten()\n",
    "    return \"\".join(tgt_vocab.to_tokens(tgt_tokens.tolist())).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "问题 1: 在一正方形花池的四周栽了temp_a棵柳树，每两棵柳树之间的间隔是temp_b米，这个正方形的周长=多少米？\n",
      "真实方程: temp_a*temp_b\n",
      "预测方程: (temp_a-1)*temp_b\n",
      "--------------------\n",
      "问题 2: 张明有temp_a元钱，买书用去temp_b%，买文具的钱是买书的temp_c%．买文具用去多少元？\n",
      "真实方程: temp_a*temp_b*temp_c\n",
      "预测方程: temp_a*temp_b/temp_c\n",
      "--------------------\n",
      "问题 3: 一个工厂要生产temp_a个零件，前temp_b天生产了temp_c个，剩下的要在temp_d天内完成，平均每天生产多少个？\n",
      "真实方程: (temp_a-temp_c)/temp_d\n",
      "预测方程: (temp_a-temp_c)/temp_d\n",
      "--------------------\n",
      "问题 4: 一本字典定价temp_a元，temp_b出售后还赚temp_c%，这本字典进价=多少元．\n",
      "真实方程: temp_a*temp_b/(1+temp_c)\n",
      "预测方程: temp_a*(1+temp_b)/(1+temp_c)\n",
      "--------------------\n",
      "问题 5: 修一段长temp_a米的路，前temp_b小时共修了temp_c米，剩下的每小时修temp_d米，还要几小时才能修完？\n",
      "真实方程: (temp_a-temp_c)/temp_d\n",
      "预测方程: (temp_a-temp_c)/temp_d\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    problem, equation = test_problems[i], test_equations[i]\n",
    "    print(f\"问题 {i+1}: {problem}\")\n",
    "    print(f\"真实方程: {''.join(equation)}\")\n",
    "    print(f\"预测方程: {inference(model, problem)}\")\n",
    "    print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:13<00:00, 73.91it/s]\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "test_loader = DataLoader(test_dataset, batch_size=1)\n",
    "preds, tgts = [], []\n",
    "for src, tgt in tqdm(test_loader):\n",
    "    pred = greedy_decode(model, src, max_len=50, start_symbol=tgt_vocab[\"<bos>\"]).flatten()\n",
    "    pred = tgt_vocab.to_tokens(pred.tolist())\n",
    "    preds.append(\"\".join(pred).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\").replace(\"<pad>\", \"\"))\n",
    "    tgts.append(\n",
    "        \"\".join(tgt_vocab.to_tokens(tgt[0].tolist())).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\").replace(\"<pad>\", \"\")\n",
    "    )\n",
    "acc = equation_accuracy(preds, tgts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "方程准确率: 0.500\n"
     ]
    }
   ],
   "source": [
    "print(f\"方程准确率: {acc:.3f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
